diff --git a/dev/.documenter-siteinfo.json b/dev/.documenter-siteinfo.json index 4e2a2eccf9..78eaf22b13 100644 --- a/dev/.documenter-siteinfo.json +++ b/dev/.documenter-siteinfo.json @@ -1 +1 @@ -{"documenter":{"julia_version":"1.11.1","generation_timestamp":"2024-11-19T18:13:11","documenter_version":"1.8.0"}} \ No newline at end of file +{"documenter":{"julia_version":"1.11.1","generation_timestamp":"2024-11-19T19:17:10","documenter_version":"1.8.0"}} \ No newline at end of file diff --git a/dev/assets/Manifest.toml b/dev/assets/Manifest.toml index ce692f665d..b721c38834 100644 --- a/dev/assets/Manifest.toml +++ b/dev/assets/Manifest.toml @@ -1555,9 +1555,9 @@ weakdeps = ["SparseArrays", "StaticArraysCore"] [[deps.SciMLStructures]] deps = ["ArrayInterface"] -git-tree-sha1 = "4cce08f7f8f9501edb1ea7b15360529745580e96" +git-tree-sha1 = "0444a37a25fab98adbd90baa806ee492a3af133a" uuid = "53ae85a6-f571-4167-b2af-e1d143709226" -version = "1.6.0" +version = "1.6.1" [[deps.Serialization]] uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" diff --git a/dev/dynamicalodeexplicit/RKN/index.html b/dev/dynamicalodeexplicit/RKN/index.html index 3c735183e2..44c05f6718 100644 --- a/dev/dynamicalodeexplicit/RKN/index.html +++ b/dev/dynamicalodeexplicit/RKN/index.html @@ -15,4 +15,4 @@ initial_velocities = [0.5, 0.0] tspan = (0.0, 1.0) prob = SecondOrderODEProblem(HH_acceleration!, initial_velocities, initial_positions, tspan) -sol = solve(prob, Nystrom4(), dt = 1 / 10)

Full list of solvers

OrdinaryDiffEqRKN.IRKN3 — Type
IRKN3()

Improved Runge-Kutta-Nyström method 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.IRKN4 — Type
IRKN4()

Improved Runge-Kutta-Nyström method 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.Nystrom4 — Type
Nystrom4()

Improved Runge-Kutta-Nyström method A 4th order explicit 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.Nystrom4VelocityIndependent — Type
Nystrom4VelocityIndependent()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.Nystrom5VelocityIndependent — Type
Nystrom5VelocityIndependent()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.FineRKN4 — Type
FineRKN4()

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

Keyword Arguments

References

@article{fine1987low, title={Low order practical {R}unge-{K}utta-{N}ystr{"o}m methods}, author={Fine, Jerry Michael}, journal={Computing}, volume={38}, number={4}, pages={281–297}, year={1987}, publisher={Springer}}

source
OrdinaryDiffEqRKN.FineRKN5 — Type
FineRKN5()

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

Keyword Arguments

References

@article{fine1987low, title={Low order practical {R}unge-{K}utta-{N}ystr{"o}m methods}, author={Fine, Jerry Michael}, journal={Computing}, volume={38}, number={4}, pages={281–297}, year={1987}, publisher={Springer}}

source
OrdinaryDiffEqRKN.DPRKN4 — Type
DPRKN4()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.DPRKN5 — Type
DPRKN5()

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

Keyword Arguments

References

@article{Bettis1973ARN, title={A Runge-Kutta Nystrom algorithm}, author={Dale G. Bettis}, journal={Celestial mechanics}, year={1973}, volume={8}, pages={229-233}, publisher={Springer}}

source
OrdinaryDiffEqRKN.DPRKN6 — Type
DPRKN6()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.DPRKN6FM — Type
DPRKN6FM()

Improved Runge-Kutta-Nyström method 6th order explicit 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.DPRKN8 — Type
DPRKN8()

Improved Runge-Kutta-Nyström method 8th order explicit 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.DPRKN12 — Type
DPRKN12()

Improved Runge-Kutta-Nyström method 12th order explicit method. The second order ODE should not depend on the first derivative. Most efficient when high accuracy is needed.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.ERKN4 — Type
ERKN4()

Improved Runge-Kutta-Nyström method Embedded 4(3) pair of explicit 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.ERKN5 — Type
ERKN5()

Improved Runge-Kutta-Nyström method Embedded 5(4) pair of explicit 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.ERKN7 — Type
ERKN7()

Improved Runge-Kutta-Nyström method Embedded pair of explicit 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.

Keyword Arguments

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
OrdinaryDiffEqRKN.RKN4 — Type
RKN4()

Improved Runge-Kutta-Nyström method 3 stage fourth order method to solve second order linear inhomogeneous IVPs. Does not include an adaptive method. Solves for for d-dimensional differential systems of second order linear inhomogeneous equations.

Warning

This method is only fourth order for these systems, the method is second order otherwise!

Keyword Arguments

References

@article{MONTIJANO2024115533, title = {Explicit Runge–Kutta–Nyström methods for the numerical solution of second order linear inhomogeneous IVPs}, author = {J.I. Montijano and L. Rández and M. Calvo}, journal = {Journal of Computational and Applied Mathematics}, volume = {438}, pages = {115533}, year = {2024},}

source
+sol = solve(prob, Nystrom4(), dt = 1 / 10)

Full list of solvers

OrdinaryDiffEqRKN.IRKN3 — Type
IRKN3()

Improved Runge-Kutta-Nyström method 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.IRKN4 — Type
IRKN4()

Improved Runge-Kutta-Nyström method 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.Nystrom4 — Type
Nystrom4()

Improved Runge-Kutta-Nyström method A 4th order explicit 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.Nystrom4VelocityIndependent — Type
Nystrom4VelocityIndependent()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.Nystrom5VelocityIndependent — Type
Nystrom5VelocityIndependent()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.FineRKN4 — Type
FineRKN4()

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

Keyword Arguments

References

@article{fine1987low, title={Low order practical {R}unge-{K}utta-{N}ystr{"o}m methods}, author={Fine, Jerry Michael}, journal={Computing}, volume={38}, number={4}, pages={281–297}, year={1987}, publisher={Springer}}

source
OrdinaryDiffEqRKN.FineRKN5 — Type
FineRKN5()

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

Keyword Arguments

References

@article{fine1987low, title={Low order practical {R}unge-{K}utta-{N}ystr{"o}m methods}, author={Fine, Jerry Michael}, journal={Computing}, volume={38}, number={4}, pages={281–297}, year={1987}, publisher={Springer}}

source
OrdinaryDiffEqRKN.DPRKN4 — Type
DPRKN4()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.DPRKN5 — Type
DPRKN5()

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

Keyword Arguments

References

@article{Bettis1973ARN, title={A Runge-Kutta Nystrom algorithm}, author={Dale G. Bettis}, journal={Celestial mechanics}, year={1973}, volume={8}, pages={229-233}, publisher={Springer}}

source
OrdinaryDiffEqRKN.DPRKN6 — Type
DPRKN6()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.DPRKN6FM — Type
DPRKN6FM()

Improved Runge-Kutta-Nyström method 6th order explicit 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.DPRKN8 — Type
DPRKN8()

Improved Runge-Kutta-Nyström method 8th order explicit 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.DPRKN12 — Type
DPRKN12()

Improved Runge-Kutta-Nyström method 12th order explicit method. The second order ODE should not depend on the first derivative. Most efficient when high accuracy is needed.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.ERKN4 — Type
ERKN4()

Improved Runge-Kutta-Nyström method Embedded 4(3) pair of explicit 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.ERKN5 — Type
ERKN5()

Improved Runge-Kutta-Nyström method Embedded 5(4) pair of explicit 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.

Keyword Arguments

References

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

source
OrdinaryDiffEqRKN.ERKN7 — Type
ERKN7()

Improved Runge-Kutta-Nyström method Embedded pair of explicit 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.

Keyword Arguments

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
OrdinaryDiffEqRKN.RKN4 — Type
RKN4()

Improved Runge-Kutta-Nyström method 3 stage fourth order method to solve second order linear inhomogeneous IVPs. Does not include an adaptive method. Solves for for d-dimensional differential systems of second order linear inhomogeneous equations.

Warning

This method is only fourth order for these systems, the method is second order otherwise!

Keyword Arguments

References

@article{MONTIJANO2024115533, title = {Explicit Runge–Kutta–Nyström methods for the numerical solution of second order linear inhomogeneous IVPs}, author = {J.I. Montijano and L. Rández and M. Calvo}, journal = {Journal of Computational and Applied Mathematics}, volume = {438}, pages = {115533}, year = {2024},}

source
diff --git a/dev/dynamicalodeexplicit/SymplecticRK/index.html b/dev/dynamicalodeexplicit/SymplecticRK/index.html index 3e93e9ffc4..5fa2782abd 100644 --- a/dev/dynamicalodeexplicit/SymplecticRK/index.html +++ b/dev/dynamicalodeexplicit/SymplecticRK/index.html @@ -15,4 +15,4 @@ initial_velocities = [0.5, 0.0] tspan = (0.0, 1.0) prob = SecondOrderODEProblem(HH_acceleration!, initial_velocities, initial_positions, tspan) -sol = solve(prob, KahanLi8(), dt = 1 / 10)

Full list of solvers

OrdinaryDiffEqSymplecticRK.SymplecticEuler — Type
SymplecticEuler()

Symplectic Runge-Kutta Methods First order explicit symplectic integrator.

Keyword Arguments

References

https://en.wikipedia.org/wiki/Semi-implicitEulermethod

source
OrdinaryDiffEqSymplecticRK.VelocityVerlet — Type
VelocityVerlet()

Symplectic Runge-Kutta Methods 2nd order explicit symplectic integrator. Requires f_2(t,u) = v, i.e. a second order ODE.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.VerletLeapfrog — Type
VerletLeapfrog()

Symplectic Runge-Kutta Methods 2nd order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.PseudoVerletLeapfrog — Type
PseudoVerletLeapfrog()

Symplectic Runge-Kutta Methods 2nd order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.McAte2 — Type
McAte2()

Symplectic Runge-Kutta Methods Optimized efficiency 2nd order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.Ruth3 — Type
Ruth3()

Symplectic Runge-Kutta Methods 3rd order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.McAte3 — Type
McAte3()

Symplectic Runge-Kutta Methods Optimized efficiency 3rd order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.CandyRoz4 — Type
CandyRoz4()

Symplectic Runge-Kutta Methods 4th order explicit symplectic integrator.

Keyword Arguments

References

@article{candy1991symplectic, itle={A symplectic integration algorithm for separable Hamiltonian functions}, uthor={Candy, J and Rozmus, W}, ournal={Journal of Computational Physics}, olume={92}, umber={1}, ages={230–256}, ear={1991}, ublisher={Elsevier}}

source
OrdinaryDiffEqSymplecticRK.McAte4 — Type
McAte4()

Symplectic Runge-Kutta Methods 4th order explicit symplectic integrator. Requires quadratic kinetic energy.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.CalvoSanz4 — Type
CalvoSanz4()

Symplectic Runge-Kutta Methods Optimized efficiency 4th order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.McAte42 — Type
McAte42()

Symplectic Runge-Kutta Methods 4th order explicit symplectic integrator. BROKEN

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.McAte5 — Type
McAte5()

Symplectic Runge-Kutta Methods Optimized efficiency 5th order explicit symplectic integrator. Requires quadratic kinetic energy.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.Yoshida6 — Type
Yoshida6()

Symplectic Runge-Kutta Methods 6th order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.KahanLi6 — Type
KahanLi6()

Symplectic Runge-Kutta Methods Optimized efficiency 6th order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.McAte8 — Type
McAte8()

Symplectic Runge-Kutta Methods 8th order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.KahanLi8 — Type
KahanLi8()

Symplectic Runge-Kutta Methods Optimized efficiency 8th order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.SofSpa10 — Type
SofSpa10()

Symplectic Runge-Kutta Methods 10th order explicit symplectic integrator.

Keyword Arguments

References

@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
+sol = solve(prob, KahanLi8(), dt = 1 / 10)

Full list of solvers

OrdinaryDiffEqSymplecticRK.SymplecticEuler — Type
SymplecticEuler()

Symplectic Runge-Kutta Methods First order explicit symplectic integrator.

Keyword Arguments

References

https://en.wikipedia.org/wiki/Semi-implicitEulermethod

source
OrdinaryDiffEqSymplecticRK.VelocityVerlet — Type
VelocityVerlet()

Symplectic Runge-Kutta Methods 2nd order explicit symplectic integrator. Requires f_2(t,u) = v, i.e. a second order ODE.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.VerletLeapfrog — Type
VerletLeapfrog()

Symplectic Runge-Kutta Methods 2nd order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.PseudoVerletLeapfrog — Type
PseudoVerletLeapfrog()

Symplectic Runge-Kutta Methods 2nd order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.McAte2 — Type
McAte2()

Symplectic Runge-Kutta Methods Optimized efficiency 2nd order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.Ruth3 — Type
Ruth3()

Symplectic Runge-Kutta Methods 3rd order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.McAte3 — Type
McAte3()

Symplectic Runge-Kutta Methods Optimized efficiency 3rd order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.CandyRoz4 — Type
CandyRoz4()

Symplectic Runge-Kutta Methods 4th order explicit symplectic integrator.

Keyword Arguments

References

@article{candy1991symplectic, itle={A symplectic integration algorithm for separable Hamiltonian functions}, uthor={Candy, J and Rozmus, W}, ournal={Journal of Computational Physics}, olume={92}, umber={1}, ages={230–256}, ear={1991}, ublisher={Elsevier}}

source
OrdinaryDiffEqSymplecticRK.McAte4 — Type
McAte4()

Symplectic Runge-Kutta Methods 4th order explicit symplectic integrator. Requires quadratic kinetic energy.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.CalvoSanz4 — Type
CalvoSanz4()

Symplectic Runge-Kutta Methods Optimized efficiency 4th order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.McAte42 — Type
McAte42()

Symplectic Runge-Kutta Methods 4th order explicit symplectic integrator. BROKEN

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.McAte5 — Type
McAte5()

Symplectic Runge-Kutta Methods Optimized efficiency 5th order explicit symplectic integrator. Requires quadratic kinetic energy.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.Yoshida6 — Type
Yoshida6()

Symplectic Runge-Kutta Methods 6th order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.KahanLi6 — Type
KahanLi6()

Symplectic Runge-Kutta Methods Optimized efficiency 6th order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.McAte8 — Type
McAte8()

Symplectic Runge-Kutta Methods 8th order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.KahanLi8 — Type
KahanLi8()

Symplectic Runge-Kutta Methods Optimized efficiency 8th order explicit symplectic integrator.

Keyword Arguments

References

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

source
OrdinaryDiffEqSymplecticRK.SofSpa10 — Type
SofSpa10()

Symplectic Runge-Kutta Methods 10th order explicit symplectic integrator.

Keyword Arguments

References

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

source
diff --git a/dev/explicit/AdamsBashforthMoulton/index.html b/dev/explicit/AdamsBashforthMoulton/index.html index 3c19b5c4b0..d4398dec9e 100644 --- a/dev/explicit/AdamsBashforthMoulton/index.html +++ b/dev/explicit/AdamsBashforthMoulton/index.html @@ -14,4 +14,4 @@ u0 = [1.0; 0.0; 0.0] tspan = (0.0, 100.0) prob = ODEProblem(lorenz!, u0, tspan) -sol = solve(prob, VCABM())

Full list of solvers

Explicit Multistep Methods

OrdinaryDiffEqAdamsBashforthMoulton.AB3 — Type
AB3()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.AB4 — Type
AB4()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.AB5 — Type
AB5()

Adams-Bashforth Explicit Method The 5-step fifth order multistep method. Ralston's 3rd order Runge-Kutta method is used to calculate starting values.

Keyword Arguments

References

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

source

Predictor-Corrector Methods

OrdinaryDiffEqAdamsBashforthMoulton.ABM32 — Type
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.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.ABM43 — Type
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.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.ABM54 — Type
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.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCAB3 — Type
VCAB3()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCAB4 — Type
VCAB4()

Adams explicit Method The 4th order Adams method. Runge-Kutta 4 is used to calculate starting values.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCAB5 — Type
VCAB5()

Adams explicit Method The 5th order Adams method. Runge-Kutta 4 is used to calculate starting values.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCABM3 — Type
VCABM3()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCABM4 — Type
VCABM4()

Adams explicit Method The 4th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCABM5 — Type
VCABM5()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCABM — Type
VCABM()

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

Keyword Arguments

References

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

source
+sol = solve(prob, VCABM())

Full list of solvers

Explicit Multistep Methods

OrdinaryDiffEqAdamsBashforthMoulton.AB3 — Type
AB3()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.AB4 — Type
AB4()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.AB5 — Type
AB5()

Adams-Bashforth Explicit Method The 5-step fifth order multistep method. Ralston's 3rd order Runge-Kutta method is used to calculate starting values.

Keyword Arguments

References

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

source

Predictor-Corrector Methods

OrdinaryDiffEqAdamsBashforthMoulton.ABM32 — Type
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.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.ABM43 — Type
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.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.ABM54 — Type
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.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCAB3 — Type
VCAB3()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCAB4 — Type
VCAB4()

Adams explicit Method The 4th order Adams method. Runge-Kutta 4 is used to calculate starting values.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCAB5 — Type
VCAB5()

Adams explicit Method The 5th order Adams method. Runge-Kutta 4 is used to calculate starting values.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCABM3 — Type
VCABM3()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCABM4 — Type
VCABM4()

Adams explicit Method The 4th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCABM5 — Type
VCABM5()

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

Keyword Arguments

References

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

source
OrdinaryDiffEqAdamsBashforthMoulton.VCABM — Type
VCABM()

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

Keyword Arguments

References

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

source
diff --git a/dev/explicit/Extrapolation/index.html b/dev/explicit/Extrapolation/index.html index c138a8c772..9220f2ca3d 100644 --- a/dev/explicit/Extrapolation/index.html +++ b/dev/explicit/Extrapolation/index.html @@ -17,14 +17,14 @@ sol = solve(prob, ExtrapolationMidpointDeuflhard())

Full list of solvers

OrdinaryDiffEqExtrapolation.AitkenNeville — Type
AitkenNeville(; max_order::Int = 10,
                 min_order::Int = 1,
                 init_order = 3,
-                thread = OrdinaryDiffEq.False())

Parallelized Explicit Extrapolation Method. Euler extrapolation using Aitken-Neville with the Romberg Sequence.

Keyword Arguments

  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
OrdinaryDiffEqExtrapolation.ExtrapolationMidpointDeuflhard — Type
ExtrapolationMidpointDeuflhard(; max_order = 10,
+                thread = OrdinaryDiffEq.False())

Parallelized Explicit Extrapolation Method. Euler extrapolation using Aitken-Neville with the Romberg Sequence.

Keyword Arguments

  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
OrdinaryDiffEqExtrapolation.ExtrapolationMidpointDeuflhard — Type
ExtrapolationMidpointDeuflhard(; max_order = 10,
                                  min_order = 1,
                                  init_order = 5,
                                  thread = OrdinaryDiffEq.True(),
                                  sequence = :harmonic,
-                                 sequence_factor = 2)

Parallelized Explicit Extrapolation Method. Midpoint extrapolation using Barycentric coordinates.

Keyword Arguments

  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • sequence: the step-number sequences, also called the subdividing sequence. Possible values are :harmonic, :romberg or :bulirsch.
  • sequence_factor: denotes which even multiple of sequence to take while evaluating internal discretizations.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
OrdinaryDiffEqExtrapolation.ExtrapolationMidpointHairerWanner — Type
ExtrapolationMidpointHairerWanner(; max_order = 10,
+                                 sequence_factor = 2)

Parallelized Explicit Extrapolation Method. Midpoint extrapolation using Barycentric coordinates.

Keyword Arguments

  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • sequence: the step-number sequences, also called the subdividing sequence. Possible values are :harmonic, :romberg or :bulirsch.
  • sequence_factor: denotes which even multiple of sequence to take while evaluating internal discretizations.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
OrdinaryDiffEqExtrapolation.ExtrapolationMidpointHairerWanner — Type
ExtrapolationMidpointHairerWanner(; max_order = 10,
                                     min_order = 2,
                                     init_order = 5,
                                     thread = OrdinaryDiffEq.True(),
                                     sequence = :harmonic,
-                                    sequence_factor = 2)

Parallelized Explicit Extrapolation Method. Midpoint extrapolation using Barycentric coordinates, following Hairer's ODEX in the adaptivity behavior.

Keyword Arguments

  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • sequence: the step-number sequences, also called the subdividing sequence. Possible values are :harmonic, :romberg or :bulirsch.
  • sequence_factor: denotes which even multiple of sequence to take while evaluating internal discretizations.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
+ sequence_factor = 2)

Parallelized Explicit Extrapolation Method. Midpoint extrapolation using Barycentric coordinates, following Hairer's ODEX in the adaptivity behavior.

Keyword Arguments

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
diff --git a/dev/explicit/Feagin/index.html b/dev/explicit/Feagin/index.html index 045e1a4989..ba278b1ad0 100644 --- a/dev/explicit/Feagin/index.html +++ b/dev/explicit/Feagin/index.html @@ -14,4 +14,4 @@ u0 = [1.0; 0.0; 0.0] tspan = (0.0, 100.0) prob = ODEProblem(lorenz!, u0, tspan) -sol = solve(prob, Feagin14())

Full list of solvers

OrdinaryDiffEqFeagin.Feagin10 — Type
Feagin10(; step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

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

References

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

source
OrdinaryDiffEqFeagin.Feagin12 — Type
Feagin12(; step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

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

References

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

source
OrdinaryDiffEqFeagin.Feagin14 — Type
Feagin14(; step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

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

References

@article{feagin2009explicit, title={An Explicit Runge-Kutta Method of Order Fourteen}, author={Feagin, Terry}, year={2009}, publisher={Numerical Algorithms} }

source
+sol = solve(prob, Feagin14())

Full list of solvers

OrdinaryDiffEqFeagin.Feagin10 — Type
Feagin10(; step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

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

References

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

source
OrdinaryDiffEqFeagin.Feagin12 — Type
Feagin12(; step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

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

References

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

source
OrdinaryDiffEqFeagin.Feagin14 — Type
Feagin14(; step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

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

References

@article{feagin2009explicit, title={An Explicit Runge-Kutta Method of Order Fourteen}, author={Feagin, Terry}, year={2009}, publisher={Numerical Algorithms} }

source
diff --git a/dev/explicit/HighOrderRK/index.html b/dev/explicit/HighOrderRK/index.html index 42d76f7445..29a2fa7280 100644 --- a/dev/explicit/HighOrderRK/index.html +++ b/dev/explicit/HighOrderRK/index.html @@ -16,11 +16,11 @@ prob = ODEProblem(lorenz!, u0, tspan) sol = solve(prob, DP8())

Full list of solvers

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

@article{tsitouras1999cheap, title={Cheap error estimation for Runge–Kutta methods}, author={Tsitouras, Ch and Papakostas, SN}, journal={SIAM Journal on Scientific Computing}, volume={20}, number={6}, pages={2067–2088}, year={1999}, publisher={SIAM}}

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

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

Keyword Arguments

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

References

@article{tsitouras1999cheap, title={Cheap error estimation for Runge–Kutta methods}, author={Tsitouras, Ch and Papakostas, SN}, journal={SIAM Journal on Scientific Computing}, volume={20}, number={6}, pages={2067–2088}, year={1999}, publisher={SIAM}}

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

@article{tsitouras2017phase, title={Phase-fitted Runge–Kutta pairs of orders 8 (7)}, author={Tsitouras, Ch and Famelis, I Th and Simos, TE}, journal={Journal of Computational and Applied Mathematics}, volume={321}, pages={226–231}, year={2017}, publisher={Elsevier}}

source
+ omega = 0.0)

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

Keyword Arguments

References

@article{tsitouras2017phase, title={Phase-fitted Runge–Kutta pairs of orders 8 (7)}, author={Tsitouras, Ch and Famelis, I Th and Simos, TE}, journal={Journal of Computational and Applied Mathematics}, volume={321}, pages={226–231}, year={2017}, publisher={Elsevier}}

source
diff --git a/dev/explicit/LowOrderRK/index.html b/dev/explicit/LowOrderRK/index.html index e039c830ab..96ea04a0c0 100644 --- a/dev/explicit/LowOrderRK/index.html +++ b/dev/explicit/LowOrderRK/index.html @@ -14,55 +14,55 @@ u0 = [1.0; 0.0; 0.0] tspan = (0.0, 100.0) prob = ODEProblem(lorenz!, u0, tspan) -sol = solve(prob, BS3())

Full list of solvers

OrdinaryDiffEqLowOrderRK.Euler — Type
Euler()

Explicit Runge-Kutta Method. The canonical forward Euler method. Fixed timestep only.

Keyword Arguments

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
OrdinaryDiffEqLowOrderRK.Heun — Type
Heun(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+sol = solve(prob, BS3())

Full list of solvers

OrdinaryDiffEqLowOrderRK.Euler — Type
Euler()

Explicit Runge-Kutta Method. The canonical forward Euler method. Fixed timestep only.

Keyword Arguments

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
OrdinaryDiffEqLowOrderRK.Heun — Type
Heun(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
        step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-       thread = OrdinaryDiffEq.False())

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. A third-order, four-stage FSAL 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)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

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

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

Explicit Runge-Kutta Method. A third-order, four-stage FSAL 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)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

(and is otherwise 4th order with less error for better estimates).

References

@article{anastassi2005optimized, title={An optimized Runge–Kutta method for the solution of orbital problems}, author={Anastassi, ZA and Simos, TE}, journal={Journal of Computational and Applied Mathematics}, volume={175}, number={1}, pages={1–9}, year={2005}, publisher={Elsevier}}

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

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

Keyword Arguments

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

(and is otherwise 4th order with less error for better estimates).

References

@article{anastassi2005optimized, title={An optimized Runge–Kutta method for the solution of orbital problems}, author={Anastassi, ZA and Simos, TE}, journal={Journal of Computational and Applied Mathematics}, volume={175}, number={1}, pages={1–9}, year={2005}, publisher={Elsevier}}

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

Explicit Runge-Kutta Method. 5th order method.

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. 5th order method.

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

when accurate this method results in zero numerical dissipation.

References

@article{medvedev2018fitted, title={Fitted modifications of Runge-Kutta pairs of orders 6 (5)}, author={Medvedev, Maxim A and Simos, TE and Tsitouras, Ch}, journal={Mathematical Methods in the Applied Sciences}, volume={41}, number={16}, pages={6184–6194}, year={2018}, publisher={Wiley Online Library}}

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

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

Keyword Arguments

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

when accurate this method results in zero numerical dissipation.

References

@article{medvedev2018fitted, title={Fitted modifications of Runge-Kutta pairs of orders 6 (5)}, author={Medvedev, Maxim A and Simos, TE and Tsitouras, Ch}, journal={Mathematical Methods in the Applied Sciences}, volume={41}, number={16}, pages={6184–6194}, year={2018}, publisher={Wiley Online Library}}

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

Explicit Runge-Kutta Method. Method designed to have good stability properties when applied to pseudospectral discretizations of hyperbolic partial differential equaitons.

Keyword Arguments

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

References

@article{mead1999optimal, title={Optimal Runge–Kutta methods for first order pseudospectral operators}, author={Mead, JL and Renaut, RA}, journal={Journal of Computational Physics}, volume={152}, number={1}, pages={404–419}, year={1999}, publisher={Elsevier} }

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

Explicit Runge-Kutta Method. Method designed to have good stability properties when applied to pseudospectral discretizations of hyperbolic partial differential equaitons.

Keyword Arguments

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

References

@article{mead1999optimal, title={Optimal Runge–Kutta methods for first order pseudospectral operators}, author={Mead, JL and Renaut, RA}, journal={Journal of Computational Physics}, volume={152}, number={1}, pages={404–419}, year={1999}, publisher={Elsevier} }

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

Explicit Runge-Kutta Method. 5th order method.

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. 5th order method.

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. 6th order method.

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. 6th order method.

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. 6-stage Pseudo-Symplectic method.

Keyword Arguments

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

References

@article{Aubry1998, author = {A. Aubry and P. Chartier}, journal = {BIT Numer. Math.}, title = {Pseudo-symplectic {R}unge-{K}utta methods}, volume = {38}, PAGES = {439-461}, year = {1998}, }, @article{Capuano2017, title = {Explicit {R}unge–{K}utta schemes for incompressible flow with improved energy-conservation properties}, journal = {J. Comput. Phys.}, volume = {328}, pages = {86-94}, year = {2017}, issn = {0021-9991}, doi = {https://doi.org/10.1016/j.jcp.2016.10.040}, author = {F. Capuano and G. Coppola and L. Rández and L. {de Luca}},}

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

Explicit Runge-Kutta Method. 6-stage Pseudo-Symplectic method.

Keyword Arguments

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

References

@article{Aubry1998, author = {A. Aubry and P. Chartier}, journal = {BIT Numer. Math.}, title = {Pseudo-symplectic {R}unge-{K}utta methods}, volume = {38}, PAGES = {439-461}, year = {1998}, }, @article{Capuano2017, title = {Explicit {R}unge–{K}utta schemes for incompressible flow with improved energy-conservation properties}, journal = {J. Comput. Phys.}, volume = {328}, pages = {86-94}, year = {2017}, issn = {0021-9991}, doi = {https://doi.org/10.1016/j.jcp.2016.10.040}, author = {F. Capuano and G. Coppola and L. Rández and L. {de Luca}},}

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

Explicit Runge-Kutta Method. 4-stage Pseudo-Symplectic method.

Keyword Arguments

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

References

@article{Aubry1998, author = {A. Aubry and P. Chartier}, journal = {BIT Numer. Math.}, title = {Pseudo-symplectic {R}unge-{K}utta methods}, year = {1998}, }, @article{Capuano2017, title = {Explicit {R}unge–{K}utta schemes for incompressible flow with improved energy-conservation properties}, journal = {J. Comput. Phys.}, year = {2017}, author = {F. Capuano and G. Coppola and L. Rández and L. {de Luca}},}

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

Explicit Runge-Kutta Method. 4-stage Pseudo-Symplectic method.

Keyword Arguments

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

References

@article{Aubry1998, author = {A. Aubry and P. Chartier}, journal = {BIT Numer. Math.}, title = {Pseudo-symplectic {R}unge-{K}utta methods}, year = {1998}, }, @article{Capuano2017, title = {Explicit {R}unge–{K}utta schemes for incompressible flow with improved energy-conservation properties}, journal = {J. Comput. Phys.}, year = {2017}, author = {F. Capuano and G. Coppola and L. Rández and L. {de Luca}},}

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

Explicit Runge-Kutta Method. 5-stage Pseudo-Symplectic method.

Keyword Arguments

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

References

@article{Aubry1998, author = {A. Aubry and P. Chartier}, journal = {BIT Numer. Math.}, title = {Pseudo-symplectic {R}unge-{K}utta methods}, year = {1998}, }, @article{Capuano2017, title = {Explicit {R}unge–{K}utta schemes for incompressible flow with improved energy-conservation properties}, journal = {J. Comput. Phys.}, year = {2017}, author = {F. Capuano and G. Coppola and L. Rández and L. {de Luca}},}

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

Explicit Runge-Kutta Method. 5-stage Pseudo-Symplectic method.

Keyword Arguments

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

References

@article{Aubry1998, author = {A. Aubry and P. Chartier}, journal = {BIT Numer. Math.}, title = {Pseudo-symplectic {R}unge-{K}utta methods}, year = {1998}, }, @article{Capuano2017, title = {Explicit {R}unge–{K}utta schemes for incompressible flow with improved energy-conservation properties}, journal = {J. Comput. Phys.}, year = {2017}, author = {F. Capuano and G. Coppola and L. Rández and L. {de Luca}},}

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

Explicit Runge-Kutta Method. 5th order method.

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. 5th order method.

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. 5th order method suited for SIR-type epidemic models.

Keyword Arguments

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

References

@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
OrdinaryDiffEqLowOrderRK.Alshina2 — Type
Alshina2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False())

Explicit Runge-Kutta Method. 5th order method suited for SIR-type epidemic models.

Keyword Arguments

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

References

@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
OrdinaryDiffEqLowOrderRK.Alshina2 — Type
Alshina2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
            step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-           thread = OrdinaryDiffEq.False())

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

Keyword Arguments

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

References

@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
OrdinaryDiffEqLowOrderRK.Alshina3 — Type
Alshina3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+           thread = OrdinaryDiffEq.False())

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

Keyword Arguments

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

References

@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
OrdinaryDiffEqLowOrderRK.Alshina3 — Type
Alshina3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
            step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-           thread = OrdinaryDiffEq.False())

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

Keyword Arguments

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

References

@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
OrdinaryDiffEqLowOrderRK.Alshina6 — Type
Alshina6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+           thread = OrdinaryDiffEq.False())

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

Keyword Arguments

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

References

@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
OrdinaryDiffEqLowOrderRK.Alshina6 — Type
Alshina6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
            step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-           thread = OrdinaryDiffEq.False())

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

Keyword Arguments

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

References

@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
+ thread = OrdinaryDiffEq.False())

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

Keyword Arguments

References

@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
diff --git a/dev/explicit/LowStorageRK/index.html b/dev/explicit/LowStorageRK/index.html index 0aac58f808..843a3bf8eb 100644 --- a/dev/explicit/LowStorageRK/index.html +++ b/dev/explicit/LowStorageRK/index.html @@ -17,101 +17,101 @@ sol = solve(prob, CarpenterKennedy2N54())

Full list of solvers

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

source
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)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

@article{kennedy2000low, title={Low-storage, explicit Runge–Kutta schemes for the compressible Navier–Stokes equations}, author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael}, journal={Applied numerical mathematics}, volume={35}, number={3}, pages={177–219}, year={2000}, publisher={Elsevier}}

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. Low dissipation and dispersion Runge-Kutta schemes for computational acoustics

Keyword Arguments

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

References

@article{stanescu19982n, title={2N-storage low dissipation and dispersion Runge-Kutta schemes for computational acoustics}, author={Stanescu, D and Habashi, WG}, journal={Journal of Computational Physics}, volume={143}, number={2}, pages={674–681}, year={1998}, publisher={Elsevier}}

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

Explicit Runge-Kutta Method. Low dissipation and dispersion Runge-Kutta schemes for computational acoustics

Keyword Arguments

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

References

@article{stanescu19982n, title={2N-storage low dissipation and dispersion Runge-Kutta schemes for computational acoustics}, author={Stanescu, D and Habashi, WG}, journal={Journal of Computational Physics}, volume={143}, number={2}, pages={674–681}, year={1998}, publisher={Elsevier}}

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

Explicit Runge-Kutta Method. Low dissipation and dispersion Runge-Kutta schemes for computational acoustics

Keyword Arguments

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

References

@article{stanescu19982n, title={2N-storage low dissipation and dispersion Runge-Kutta schemes for computational acoustics}, author={Stanescu, D and Habashi, WG}, journal={Journal of Computational Physics}, volume={143}, number={2}, pages={674–681}, year={1998}, publisher={Elsevier}}

source
+ thread = OrdinaryDiffEq.False())

Explicit Runge-Kutta Method. Low dissipation and dispersion Runge-Kutta schemes for computational acoustics

Keyword Arguments

References

@article{stanescu19982n, title={2N-storage low dissipation and dispersion Runge-Kutta schemes for computational acoustics}, author={Stanescu, D and Habashi, WG}, journal={Journal of Computational Physics}, volume={143}, number={2}, pages={674–681}, year={1998}, publisher={Elsevier}}

source
diff --git a/dev/explicit/PRK/index.html b/dev/explicit/PRK/index.html index 4ee816caf4..48323b9716 100644 --- a/dev/explicit/PRK/index.html +++ b/dev/explicit/PRK/index.html @@ -14,4 +14,4 @@ u0 = [1.0; 0.0; 0.0] tspan = (0.0, 100.0) prob = ODEProblem(lorenz!, u0, tspan) -sol = solve(prob, KuttaPRK2p5())

Full list of solvers

OrdinaryDiffEqPRK.KuttaPRK2p5 — Type
KuttaPRK2p5(; thread = OrdinaryDiffEq.True())

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

Keyword Arguments

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

References

@article{jackson1995potential, title={The potential for parallelism in Runge–Kutta methods. Part 1: RK formulas in standard form}, author={Jackson, Kenneth R and Norsett, Syvert Paul}, journal={SIAM journal on numerical analysis}, volume={32}, number={1}, pages={49–82}, year={1995}, publisher={SIAM}}

source
+sol = solve(prob, KuttaPRK2p5())

Full list of solvers

OrdinaryDiffEqPRK.KuttaPRK2p5 — Type
KuttaPRK2p5(; thread = OrdinaryDiffEq.True())

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

Keyword Arguments

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

References

@article{jackson1995potential, title={The potential for parallelism in Runge–Kutta methods. Part 1: RK formulas in standard form}, author={Jackson, Kenneth R and Norsett, Syvert Paul}, journal={SIAM journal on numerical analysis}, volume={32}, number={1}, pages={49–82}, year={1995}, publisher={SIAM}}

source
diff --git a/dev/explicit/QPRK/index.html b/dev/explicit/QPRK/index.html index 45f717e0f9..3622f8d8ad 100644 --- a/dev/explicit/QPRK/index.html +++ b/dev/explicit/QPRK/index.html @@ -16,4 +16,4 @@ prob = ODEProblem(lorenz!, u0, tspan) sol = solve(prob, QPRK98())

Full list of solvers

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

Explicit Runge-Kutta Method. Runge–Kutta pairs of orders 9(8) for use in quadruple precision computations

Keyword Arguments

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

References

Kovalnogov VN, Fedorov RV, Karpukhina TV, Simos TE, Tsitouras C. Runge–Kutta pairs of orders 9 (8) for use in quadruple precision computations. Numerical Algorithms, 2023. doi: https://doi.org/10.1007/s11075-023-01632-8

source
+ thread = OrdinaryDiffEq.False())

Explicit Runge-Kutta Method. Runge–Kutta pairs of orders 9(8) for use in quadruple precision computations

Keyword Arguments

References

Kovalnogov VN, Fedorov RV, Karpukhina TV, Simos TE, Tsitouras C. Runge–Kutta pairs of orders 9 (8) for use in quadruple precision computations. Numerical Algorithms, 2023. doi: https://doi.org/10.1007/s11075-023-01632-8

source
diff --git a/dev/explicit/SSPRK/index.html b/dev/explicit/SSPRK/index.html index 4febade419..f1d3b8def0 100644 --- a/dev/explicit/SSPRK/index.html +++ b/dev/explicit/SSPRK/index.html @@ -16,38 +16,38 @@ prob = ODEProblem(lorenz!, u0, tspan) sol = solve(prob, SSPRK22())

Full list of solvers

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. Optimal strong-stability-preserving Runge-Kutta time discretizations for discontinuous Galerkin methods

Keyword Arguments

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

References

@article{kubatko2014optimal, title={Optimal strong-stability-preserving Runge–Kutta time discretizations for discontinuous Galerkin methods}, author={Kubatko, Ethan J and Yeager, Benjamin A and Ketcheson, David I}, journal={Journal of Scientific Computing}, volume={60}, pages={313–344}, year={2014}, publisher={Springer}}

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

Explicit Runge-Kutta Method. Optimal strong-stability-preserving Runge-Kutta time discretizations for discontinuous Galerkin methods

Keyword Arguments

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

References

@article{kubatko2014optimal, title={Optimal strong-stability-preserving Runge–Kutta time discretizations for discontinuous Galerkin methods}, author={Kubatko, Ethan J and Yeager, Benjamin A and Ketcheson, David I}, journal={Journal of Scientific Computing}, volume={60}, pages={313–344}, year={2014}, publisher={Springer}}

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

Explicit Runge-Kutta Method. Optimal strong-stability-preserving Runge-Kutta time discretizations for discontinuous Galerkin methods

Keyword Arguments

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

References

@article{kubatko2014optimal, title={Optimal strong-stability-preserving Runge–Kutta time discretizations for discontinuous Galerkin methods}, author={Kubatko, Ethan J and Yeager, Benjamin A and Ketcheson, David I}, journal={Journal of Scientific Computing}, volume={60}, pages={313–344}, year={2014}, publisher={Springer}}

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

Explicit Runge-Kutta Method. Optimal strong-stability-preserving Runge-Kutta time discretizations for discontinuous Galerkin methods

Keyword Arguments

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

References

@article{kubatko2014optimal, title={Optimal strong-stability-preserving Runge–Kutta time discretizations for discontinuous Galerkin methods}, author={Kubatko, Ethan J and Yeager, Benjamin A and Ketcheson, David I}, journal={Journal of Scientific Computing}, volume={60}, pages={313–344}, year={2014}, publisher={Springer}}

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. A third-order, four-stage explicit strong stability preserving (SSP) method.

Keyword Arguments

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

References

Optimal third-order explicit SSP method with four stages discovered by

  • J. F. B. M. Kraaijevanger. "Contractivity of Runge-Kutta methods." In: BIT Numerical Mathematics 31.3 (1991), pp. 482–528. DOI: 10.1007/BF01933264.

Embedded method constructed by

  • Sidafa Conde, Imre Fekete, John N. Shadid. "Embedded error estimation and adaptive step-size control for optimal explicit strong stability preserving Runge–Kutta methods." arXiv: 1806.08693

Efficient implementation (and optimized controller) developed by

  • Hendrik Ranocha, Lisandro Dalcin, Matteo Parsani, David I. Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836
source
OrdinaryDiffEqSSPRK.SSPRK432 — Type
SSPRK432(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          thread = OrdinaryDiffEq.False())

Explicit Runge-Kutta Method. A third-order, four-stage explicit strong stability preserving (SSP) method.

Keyword Arguments

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

References

Optimal third-order explicit SSP method with four stages discovered by

  • J. F. B. M. Kraaijevanger. "Contractivity of Runge-Kutta methods." In: BIT Numerical Mathematics 31.3 (1991), pp. 482–528. DOI: 10.1007/BF01933264.

Embedded method constructed by

  • Sidafa Conde, Imre Fekete, John N. Shadid. "Embedded error estimation and adaptive step-size control for optimal explicit strong stability preserving Runge–Kutta methods." arXiv: 1806.08693

Efficient implementation (and optimized controller) developed by

  • Hendrik Ranocha, Lisandro Dalcin, Matteo Parsani, David I. Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836
source
OrdinaryDiffEqSSPRK.SSPRK432 — Type
SSPRK432(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
            step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-           thread = OrdinaryDiffEq.False())

Explicit Runge-Kutta Method. A third-order, four-stage explicit strong stability preserving (SSP) method.

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. A third-order, four-stage explicit strong stability preserving (SSP) method.

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. A third-order, four-step explicit strong stability preserving (SSP) linear multistep method. This method does not come with an error estimator and requires a fixed time step size.

Keyword Arguments

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

References

Shu, Chi-Wang. Total-variation-diminishing time discretizations. SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. DOI: 10.1137/0909073

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

Explicit Runge-Kutta Method. A third-order, four-step explicit strong stability preserving (SSP) linear multistep method. This method does not come with an error estimator and requires a fixed time step size.

Keyword Arguments

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

References

Shu, Chi-Wang. Total-variation-diminishing time discretizations. SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. DOI: 10.1137/0909073

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

Explicit Runge-Kutta Method. A second-order, three-step explicit strong stability preserving (SSP) linear multistep method. This method does not come with an error estimator and requires a fixed time step size.

Keyword Arguments

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

References

Shu, Chi-Wang. Total-variation-diminishing time discretizations. SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. DOI: 10.1137/0909073

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

Explicit Runge-Kutta Method. A second-order, three-step explicit strong stability preserving (SSP) linear multistep method. This method does not come with an error estimator and requires a fixed time step size.

Keyword Arguments

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

References

Shu, Chi-Wang. Total-variation-diminishing time discretizations. SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. DOI: 10.1137/0909073

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

Explicit Runge-Kutta Method. A third-order, nine-stage explicit strong stability preserving (SSP) method.

Consider using SSPRK43 instead, which uses the same main method and an improved embedded method.

Keyword Arguments

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

References

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

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

Explicit Runge-Kutta Method. A third-order, nine-stage explicit strong stability preserving (SSP) method.

Consider using SSPRK43 instead, which uses the same main method and an improved embedded method.

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

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

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

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

Keyword Arguments

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

References

Ketcheson, David I. Highly efficient strong stability-preserving Runge–Kutta methods with low-storage implementations. SIAM Journal on Scientific Computing 30.4 (2008): 2113-2136.

source
+ thread = OrdinaryDiffEq.False())

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

Keyword Arguments

References

Ketcheson, David I. Highly efficient strong stability-preserving Runge–Kutta methods with low-storage implementations. SIAM Journal on Scientific Computing 30.4 (2008): 2113-2136.

source
diff --git a/dev/explicit/Tsit5/index.html b/dev/explicit/Tsit5/index.html index 6d3c55fa36..d19a4aef4e 100644 --- a/dev/explicit/Tsit5/index.html +++ b/dev/explicit/Tsit5/index.html @@ -16,4 +16,4 @@ prob = ODEProblem(lorenz!, u0, tspan) sol = solve(prob, Tsit5())

Full list of solvers

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

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

Keyword Arguments

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

References

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

source
OrdinaryDiffEqTsit5.AutoTsit5 — Function

Automatic switching algorithm that can switch between the (non-stiff) Tsit5() and stiff_alg.

AutoTsit5(stiff_alg; kwargs...)

This method is equivalent to AutoAlgSwitch(Tsit5(), stiff_alg; kwargs...). To gain access to stiff algorithms you might have to install additional libraries, such as OrdinaryDiffEqRosenbrock.

source
+ thread = OrdinaryDiffEq.False())

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

Keyword Arguments

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
OrdinaryDiffEqTsit5.AutoTsit5 — Function

Automatic switching algorithm that can switch between the (non-stiff) Tsit5() and stiff_alg.

AutoTsit5(stiff_alg; kwargs...)

This method is equivalent to AutoAlgSwitch(Tsit5(), stiff_alg; kwargs...). To gain access to stiff algorithms you might have to install additional libraries, such as OrdinaryDiffEqRosenbrock.

source
diff --git a/dev/explicit/Verner/index.html b/dev/explicit/Verner/index.html index 43317e7a61..f8548f71bc 100644 --- a/dev/explicit/Verner/index.html +++ b/dev/explicit/Verner/index.html @@ -17,13 +17,13 @@ sol = solve(prob, Vern6())

Full list of solvers

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

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

Keyword Arguments

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

References

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

source
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)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

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

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

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

Keyword Arguments

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

References

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

source
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)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

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

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

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

Keyword Arguments

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

References

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

source
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)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

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

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

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

Keyword Arguments

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

References

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

source
OrdinaryDiffEqVerner.AutoVern6 — Function

Automatic switching algorithm that can switch between the (non-stiff) Vern6() and stiff_alg.

AutoVern6(stiff_alg; kwargs...)

This method is equivalent to AutoAlgSwitch(Vern6(), stiff_alg; kwargs...). To gain access to stiff algorithms you might have to install additional libraries, such as OrdinaryDiffEqRosenbrock.

source
OrdinaryDiffEqVerner.AutoVern7 — Function

Automatic switching algorithm that can switch between the (non-stiff) Vern7() and stiff_alg.

AutoVern7(stiff_alg; kwargs...)

This method is equivalent to AutoAlgSwitch(Vern7(), stiff_alg; kwargs...). To gain access to stiff algorithms you might have to install additional libraries, such as OrdinaryDiffEqRosenbrock.

source
OrdinaryDiffEqVerner.AutoVern8 — Function

Automatic switching algorithm that can switch between the (non-stiff) Vern8() and stiff_alg.

AutoVern8(stiff_alg; kwargs...)

This method is equivalent to AutoAlgSwitch(Vern8(), stiff_alg; kwargs...). To gain access to stiff algorithms you might have to install additional libraries, such as OrdinaryDiffEqRosenbrock.

source
OrdinaryDiffEqVerner.AutoVern9 — Function

Automatic switching algorithm that can switch between the (non-stiff) Vern9() and stiff_alg.

AutoVern9(stiff_alg; kwargs...)

This method is equivalent to AutoAlgSwitch(Vern9(), stiff_alg; kwargs...). To gain access to stiff algorithms you might have to install additional libraries, such as OrdinaryDiffEqRosenbrock.

source
+ lazy = true)

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

Keyword Arguments

References

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

source
OrdinaryDiffEqVerner.AutoVern6 — Function

Automatic switching algorithm that can switch between the (non-stiff) Vern6() and stiff_alg.

AutoVern6(stiff_alg; kwargs...)

This method is equivalent to AutoAlgSwitch(Vern6(), stiff_alg; kwargs...). To gain access to stiff algorithms you might have to install additional libraries, such as OrdinaryDiffEqRosenbrock.

source
OrdinaryDiffEqVerner.AutoVern7 — Function

Automatic switching algorithm that can switch between the (non-stiff) Vern7() and stiff_alg.

AutoVern7(stiff_alg; kwargs...)

This method is equivalent to AutoAlgSwitch(Vern7(), stiff_alg; kwargs...). To gain access to stiff algorithms you might have to install additional libraries, such as OrdinaryDiffEqRosenbrock.

source
OrdinaryDiffEqVerner.AutoVern8 — Function

Automatic switching algorithm that can switch between the (non-stiff) Vern8() and stiff_alg.

AutoVern8(stiff_alg; kwargs...)

This method is equivalent to AutoAlgSwitch(Vern8(), stiff_alg; kwargs...). To gain access to stiff algorithms you might have to install additional libraries, such as OrdinaryDiffEqRosenbrock.

source
OrdinaryDiffEqVerner.AutoVern9 — Function

Automatic switching algorithm that can switch between the (non-stiff) Vern9() and stiff_alg.

AutoVern9(stiff_alg; kwargs...)

This method is equivalent to AutoAlgSwitch(Vern9(), stiff_alg; kwargs...). To gain access to stiff algorithms you might have to install additional libraries, such as OrdinaryDiffEqRosenbrock.

source
diff --git a/dev/fullyimplicitdae/BDF/index.html b/dev/fullyimplicitdae/BDF/index.html index a60e628a9b..6ea83123d9 100644 --- a/dev/fullyimplicitdae/BDF/index.html +++ b/dev/fullyimplicitdae/BDF/index.html @@ -15,7 +15,7 @@ precs = DEFAULT_PRECS, nlsolve = NLNewton(), extrapolant = :constant, - controller = :Standard)

Multistep Method. Implicit Euler for implicit DAE form. It uses an apriori error estimator for adaptivity based on a finite differencing approximation from SPICE.

Keyword Arguments

References

source
OrdinaryDiffEqBDF.DABDF2 — Type
DABDF2(; chunk_size = Val{0}(),
+                 controller = :Standard)

Multistep Method. Implicit Euler for implicit DAE form. It uses an apriori error estimator for adaptivity based on a finite differencing approximation from SPICE.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify DImplicitEuler(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • controller: TBD

References

source
OrdinaryDiffEqBDF.DABDF2 — Type
DABDF2(; chunk_size = Val{0}(),
          autodiff = true,
          standardtag = Val{true}(),
          concrete_jac = nothing,
@@ -24,7 +24,7 @@
          precs = DEFAULT_PRECS,
          nlsolve = NLNewton(),
          extrapolant = :constant,
-         controller = :Standard)

Multistep Method. Fully implicit implementation of BDF2.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify DABDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • controller: TBD

References

@article{celaya2014implementation, title={Implementation of an Adaptive BDF2 Formula and Comparison with the MATLAB Ode15s}, author={Celaya, E Alberdi and Aguirrezabala, JJ Anza and Chatzipantelidis, Panagiotis}, journal={Procedia Computer Science}, volume={29}, pages={1014–1026}, year={2014}, publisher={Elsevier}}

source
OrdinaryDiffEqBDF.DFBDF — Type
DFBDF(; chunk_size = Val{0}(),
+         controller = :Standard)

Multistep Method. Fully implicit implementation of BDF2.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify DABDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • controller: TBD

References

@article{celaya2014implementation, title={Implementation of an Adaptive BDF2 Formula and Comparison with the MATLAB Ode15s}, author={Celaya, E Alberdi and Aguirrezabala, JJ Anza and Chatzipantelidis, Panagiotis}, journal={Procedia Computer Science}, volume={29}, pages={1014–1026}, year={2014}, publisher={Elsevier}}

source
OrdinaryDiffEqBDF.DFBDF — Type
DFBDF(; chunk_size = Val{0}(),
         autodiff = true,
         standardtag = Val{true}(),
         concrete_jac = nothing,
@@ -36,4 +36,4 @@
         nlsolve = NLNewton(),
         extrapolant = :linear,
         controller = :Standard,
-        max_order::Val{MO} = Val{5}())

Multistep Method. Fully implicit implementation of FBDF based on Shampine's

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify DFBDF(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- κ: TBD
  • tol: TBD
  • nlsolve: TBD
  • extrapolant: TBD
  • controller: TBD
  • max_order: TBD

References

@article{shampine2002solving, title={Solving 0= F (t, y (t), y′(t)) in Matlab}, author={Shampine, Lawrence F}, year={2002}, publisher={Walter de Gruyter GmbH and Co. KG} }

source
+ max_order::Val{MO} = Val{5}())

Multistep Method. Fully implicit implementation of FBDF based on Shampine's

Keyword Arguments

References

@article{shampine2002solving, title={Solving 0= F (t, y (t), y′(t)) in Matlab}, author={Shampine, Lawrence F}, year={2002}, publisher={Walter de Gruyter GmbH and Co. KG} }

source
diff --git a/dev/imex/IMEXBDF/index.html b/dev/imex/IMEXBDF/index.html index 439b890ee0..1ec17a5c71 100644 --- a/dev/imex/IMEXBDF/index.html +++ b/dev/imex/IMEXBDF/index.html @@ -10,5 +10,5 @@ u0 = 1.0 tspan = (0.0, 1.0) prob = SplitODEProblem(f1, f2, u0, tspan) -sol = solve(prob, SBDF2(), dt = 1 / 10)

Full list of solvers

IMEX Multistep

Missing docstring.

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

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

The two-step version of the IMEX multistep methods of

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

See also SBDF.

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

The three-step version of the IMEX multistep methods of

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

See also SBDF.

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

The four-step version of the IMEX multistep methods of

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

See also SBDF.

source

IMEX SDIRK

Note that Implicit Euler is the 1st order BDF method, and is thus implemented here using the same machinery.

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

The one-step version of the IMEX multistep methods of

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

When applied to a SplitODEProblem of the form

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

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

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

See also SBDF, IMEXEulerARK.

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

The one-step version of the IMEX multistep methods of

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

When applied to a SplitODEProblem of the form

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

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

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

See also SBDF, IMEXEuler.

source
+sol = solve(prob, SBDF2(), dt = 1 / 10)

Full list of solvers

IMEX Multistep

Missing docstring.

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

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

The two-step version of the IMEX multistep methods of

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

See also SBDF.

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

The three-step version of the IMEX multistep methods of

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

See also SBDF.

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

The four-step version of the IMEX multistep methods of

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

See also SBDF.

source

IMEX SDIRK

Note that Implicit Euler is the 1st order BDF method, and is thus implemented here using the same machinery.

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

The one-step version of the IMEX multistep methods of

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

When applied to a SplitODEProblem of the form

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

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

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

See also SBDF, IMEXEulerARK.

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

The one-step version of the IMEX multistep methods of

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

When applied to a SplitODEProblem of the form

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

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

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

See also SBDF, IMEXEuler.

source
diff --git a/dev/imex/IMEXMultistep/index.html b/dev/imex/IMEXMultistep/index.html index 21dae7eff2..6180987d9f 100644 --- a/dev/imex/IMEXMultistep/index.html +++ b/dev/imex/IMEXMultistep/index.html @@ -10,4 +10,4 @@ u0 = 1.0 tspan = (0.0, 1.0) prob = SplitODEProblem(f1, f2, u0, tspan) -sol = solve(prob, CNAB2(), dt = 1 / 10)

Full list of solvers

OrdinaryDiffEqIMEXMultistep.CNAB2 — Type
CNAB2()

IMEX Multistep method. Crank-Nicholson Adams-Bashforth 2.

Keyword Arguments

References

@article{jorgenson2014unconditional, title={Unconditional stability of a Crank-Nicolson Adams-Bashforth 2 numerical method}, author={JORGENSON, ANDREW D}, journal={A (A- C)}, volume={1}, number={2}, pages={1}, year={2014}} @article{he2010numerical, title={Numerical implementation of the Crank–Nicolson/Adams–Bashforth scheme for the time-dependent Navier–Stokes equations}, author={He, Yinnian and Li, Jian}, journal={International journal for numerical methods in fluids}, volume={62}, number={6}, pages={647–659}, year={2010}, publisher={Wiley Online Library}}

source
OrdinaryDiffEqIMEXMultistep.CNLF2 — Type
CNLF2()

IMEX Multistep method. Crank-Nicholson Leapfrong 2.

Keyword Arguments

References

@article{han2020second, title={A second order, linear, unconditionally stable, Crank–Nicolson–Leapfrog scheme for phase field models of two-phase incompressible flows}, author={Han, Daozhi and Jiang, Nan}, journal={Applied Mathematics Letters}, volume={108}, pages={106521}, year={2020}, publisher={Elsevier}} @article{jiang2015crank, title={A Crank–Nicolson Leapfrog stabilization: Unconditional stability and two applications}, author={Jiang, Nan and Kubacki, Michaela and Layton, William and Moraiti, Marina and Tran, Hoang}, journal={Journal of Computational and Applied Mathematics}, volume={281}, pages={263–276}, year={2015}, publisher={Elsevier}}

source
+sol = solve(prob, CNAB2(), dt = 1 / 10)

Full list of solvers

OrdinaryDiffEqIMEXMultistep.CNAB2 — Type
CNAB2()

IMEX Multistep method. Crank-Nicholson Adams-Bashforth 2.

Keyword Arguments

References

@article{jorgenson2014unconditional, title={Unconditional stability of a Crank-Nicolson Adams-Bashforth 2 numerical method}, author={JORGENSON, ANDREW D}, journal={A (A- C)}, volume={1}, number={2}, pages={1}, year={2014}} @article{he2010numerical, title={Numerical implementation of the Crank–Nicolson/Adams–Bashforth scheme for the time-dependent Navier–Stokes equations}, author={He, Yinnian and Li, Jian}, journal={International journal for numerical methods in fluids}, volume={62}, number={6}, pages={647–659}, year={2010}, publisher={Wiley Online Library}}

source
OrdinaryDiffEqIMEXMultistep.CNLF2 — Type
CNLF2()

IMEX Multistep method. Crank-Nicholson Leapfrong 2.

Keyword Arguments

References

@article{han2020second, title={A second order, linear, unconditionally stable, Crank–Nicolson–Leapfrog scheme for phase field models of two-phase incompressible flows}, author={Han, Daozhi and Jiang, Nan}, journal={Applied Mathematics Letters}, volume={108}, pages={106521}, year={2020}, publisher={Elsevier}} @article{jiang2015crank, title={A Crank–Nicolson Leapfrog stabilization: Unconditional stability and two applications}, author={Jiang, Nan and Kubacki, Michaela and Layton, William and Moraiti, Marina and Tran, Hoang}, journal={Journal of Computational and Applied Mathematics}, volume={281}, pages={263–276}, year={2015}, publisher={Elsevier}}

source
diff --git a/dev/imex/StabilizedIRK/index.html b/dev/imex/StabilizedIRK/index.html index 98e1ea4291..bfdc5223de 100644 --- a/dev/imex/StabilizedIRK/index.html +++ b/dev/imex/StabilizedIRK/index.html @@ -12,4 +12,4 @@ u0 = randn(20, 1) tspan = (0.0, 1.0) prob = SplitODEProblem(f1, f2, u0, tspan) -sol = solve(prob, IRKC())

Full list of solvers

OrdinaryDiffEqStabilizedIRK.IRKC — Type
IRKC(; eigen_est = nothing)

Stabilized Implicit Runge Kutta method. Implicit Runge-Kutta-Chebyshev method.

Keyword Arguments

  • eigen_est: function of the form (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.

References

REF TBD

source
+sol = solve(prob, IRKC())

Full list of solvers

OrdinaryDiffEqStabilizedIRK.IRKC — Type
IRKC(; eigen_est = nothing)

Stabilized Implicit Runge Kutta method. Implicit Runge-Kutta-Chebyshev method.

Keyword Arguments

  • eigen_est: function of the form (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.

References

REF TBD

source
diff --git a/dev/implicit/BDF/index.html b/dev/implicit/BDF/index.html index e1d58225c9..6469f547a0 100644 --- a/dev/implicit/BDF/index.html +++ b/dev/implicit/BDF/index.html @@ -27,7 +27,7 @@ smooth_est = true, extrapolant = :linear, controller = :Standard, - step_limiter! = trivial_limiter!)

Multistep Method. An adaptive order 2 L-stable fixed leading coefficient multistep BDF method.

Keyword Arguments

References

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

source
OrdinaryDiffEqBDF.QNDF — Type
QNDF(; chunk_size = Val{0}(),
+        step_limiter! = trivial_limiter!)

Multistep Method. An adaptive order 2 L-stable fixed leading coefficient multistep BDF method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ABDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- κ: TBD
  • tol: TBD
  • nlsolve: TBD
  • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEqBDF.QNDF — Type
QNDF(; chunk_size = Val{0}(),
        autodiff = true,
        standardtag = Val{true}(),
        concrete_jac = nothing,
@@ -40,7 +40,7 @@
        extrapolant = :linear,
        kappa =  promote(-0.1850, -1 // 9, -0.0823, -0.0415, 0),
        controller = :Standard,
-       step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- κ: TBD
  • tol: TBD
  • nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QNDF1 — Type
QNDF1(; chunk_size = Val{0}(),
+       step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- κ: TBD
  • tol: TBD
  • nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QNDF1 — Type
QNDF1(; chunk_size = Val{0}(),
         autodiff = true,
         standardtag = Val{true}(),
         concrete_jac = nothing,
@@ -51,7 +51,7 @@
         extrapolant = :linear,
         kappa = -0.1850,
         controller = :Standard,
-        step_limiter! = trivial_limiter!)

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.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF1(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QNDF2 — Type
QNDF2(; chunk_size = Val{0}(),
+        step_limiter! = trivial_limiter!)

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.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF1(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QNDF2 — Type
QNDF2(; chunk_size = Val{0}(),
         autodiff = true,
         standardtag = Val{true}(),
         concrete_jac = nothing,
@@ -62,7 +62,7 @@
         extrapolant = :linear,
         kappa =  -1 // 9,
         controller = :Standard,
-        step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QBDF — Function

QBDF: Multistep Method

An alias of QNDF with κ=0.

source
OrdinaryDiffEqBDF.QBDF1 — Function

QBDF1: Multistep Method

An alias of QNDF1 with κ=0.

source
OrdinaryDiffEqBDF.QBDF2 — Function

QBDF2: Multistep Method

An alias of QNDF2 with κ=0.

source
OrdinaryDiffEqBDF.MEBDF2 — Type
MEBDF2(; chunk_size = Val{0}(),
+        step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QBDF — Function

QBDF: Multistep Method

An alias of QNDF with κ=0.

source
OrdinaryDiffEqBDF.QBDF1 — Function

QBDF1: Multistep Method

An alias of QNDF1 with κ=0.

source
OrdinaryDiffEqBDF.QBDF2 — Function

QBDF2: Multistep Method

An alias of QNDF2 with κ=0.

source
OrdinaryDiffEqBDF.MEBDF2 — Type
MEBDF2(; chunk_size = Val{0}(),
          autodiff = true,
          standardtag = Val{true}(),
          concrete_jac = nothing,
@@ -70,7 +70,7 @@
          linsolve = nothing,
          precs = DEFAULT_PRECS,
          nlsolve = NLNewton(),
-         extrapolant = :constant)

Multistep Method. The second order Modified Extended BDF method, which has improved stability properties over the standard BDF. Fixed timestep only.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify MEBDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD

References

@article{cash2000modified, title={Modified extended backward differentiation formulae for the numerical solution of stiff initial value problems in ODEs and DAEs}, author={Cash, JR}, journal={Journal of Computational and Applied Mathematics}, volume={125}, number={1-2}, pages={117–130}, year={2000}, publisher={Elsevier}}

source
OrdinaryDiffEqBDF.FBDF — Type
FBDF(; chunk_size = Val{0}(),
+         extrapolant = :constant)

Multistep Method. The second order Modified Extended BDF method, which has improved stability properties over the standard BDF. Fixed timestep only.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify MEBDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD

References

@article{cash2000modified, title={Modified extended backward differentiation formulae for the numerical solution of stiff initial value problems in ODEs and DAEs}, author={Cash, JR}, journal={Journal of Computational and Applied Mathematics}, volume={125}, number={1-2}, pages={117–130}, year={2000}, publisher={Elsevier}}

source
OrdinaryDiffEqBDF.FBDF — Type
FBDF(; chunk_size = Val{0}(),
        autodiff = true,
        standardtag = Val{true}(),
        concrete_jac = nothing,
@@ -83,4 +83,4 @@
        extrapolant = :linear,
        controller = :Standard,
        step_limiter! = trivial_limiter!,
-       max_order::Val{MO} = Val{5}())

Multistep Method. An adaptive order quasi-constant timestep NDF method. Fixed leading coefficient BDF. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients).

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify FBDF(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- κ: TBD
  • tol: TBD
  • nlsolve: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • max_order: TBD

References

@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
+ max_order::Val{MO} = Val{5}())

Multistep Method. An adaptive order quasi-constant timestep NDF method. Fixed leading coefficient BDF. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients).

Keyword Arguments

References

@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/dev/implicit/Extrapolation/index.html b/dev/implicit/Extrapolation/index.html index 7812c948b8..8b9963ca9a 100644 --- a/dev/implicit/Extrapolation/index.html +++ b/dev/implicit/Extrapolation/index.html @@ -25,7 +25,7 @@ min_order = 3, init_order = 5, thread = OrdinaryDiffEq.False(), - sequence = :harmonic)

Parallelized Explicit Extrapolation Method. Extrapolation of implicit Euler method with Romberg sequence. Similar to Hairer's SEULEX.

Keyword Arguments

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
OrdinaryDiffEqExtrapolation.ImplicitDeuflhardExtrapolation — Type
ImplicitDeuflhardExtrapolation(; chunk_size = Val{0}(),
+                             sequence = :harmonic)

Parallelized Explicit Extrapolation Method. Extrapolation of implicit Euler method with Romberg sequence. Similar to Hairer's SEULEX.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ImplicitEulerExtrapolation(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • sequence: the step-number sequences, also called the subdividing sequence. Possible values are :harmonic, :romberg or :bulirsch.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
OrdinaryDiffEqExtrapolation.ImplicitDeuflhardExtrapolation — Type
ImplicitDeuflhardExtrapolation(; chunk_size = Val{0}(),
                                  autodiff = true,
                                  standardtag = Val{true}(),
                                  concrete_jac = nothing,
@@ -36,7 +36,7 @@
                                  min_order = 1,
                                  init_order = 5,
                                  thread = OrdinaryDiffEq.False(),
-                                 sequence = :harmonic)

Parallelized Explicit Extrapolation Method. Midpoint extrapolation using Barycentric coordinates.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ImplicitDeuflhardExtrapolation(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • sequence: the step-number sequences, also called the subdividing sequence. Possible values are :harmonic, :romberg or :bulirsch.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
OrdinaryDiffEqExtrapolation.ImplicitHairerWannerExtrapolation — Type
ImplicitHairerWannerExtrapolation(; chunk_size = Val{0}(),
+                                 sequence = :harmonic)

Parallelized Explicit Extrapolation Method. Midpoint extrapolation using Barycentric coordinates.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ImplicitDeuflhardExtrapolation(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • sequence: the step-number sequences, also called the subdividing sequence. Possible values are :harmonic, :romberg or :bulirsch.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
OrdinaryDiffEqExtrapolation.ImplicitHairerWannerExtrapolation — Type
ImplicitHairerWannerExtrapolation(; chunk_size = Val{0}(),
                                     autodiff = true,
                                     standardtag = Val{true}(),
                                     concrete_jac = nothing,
@@ -47,7 +47,7 @@
                                     min_order = 2,
                                     init_order = 5,
                                     thread = OrdinaryDiffEq.False(),
-                                    sequence = :harmonic)

Parallelized Explicit Extrapolation Method. Midpoint extrapolation using Barycentric coordinates, following Hairer's SODEX in the adaptivity behavior.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ImplicitHairerWannerExtrapolation(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • sequence: the step-number sequences, also called the subdividing sequence. Possible values are :harmonic, :romberg or :bulirsch.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
OrdinaryDiffEqExtrapolation.ImplicitEulerBarycentricExtrapolation — Type
ImplicitEulerBarycentricExtrapolation(; chunk_size = Val{0}(),
+                                    sequence = :harmonic)

Parallelized Explicit Extrapolation Method. Midpoint extrapolation using Barycentric coordinates, following Hairer's SODEX in the adaptivity behavior.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ImplicitHairerWannerExtrapolation(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • sequence: the step-number sequences, also called the subdividing sequence. Possible values are :harmonic, :romberg or :bulirsch.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
OrdinaryDiffEqExtrapolation.ImplicitEulerBarycentricExtrapolation — Type
ImplicitEulerBarycentricExtrapolation(; chunk_size = Val{0}(),
                                         autodiff = true,
                                         standardtag = Val{true}(),
                                         concrete_jac = nothing,
@@ -59,4 +59,4 @@
                                         init_order = 5,
                                         thread = OrdinaryDiffEq.False(),
                                         sequence = :harmonic,
-                                        sequence_factor = 2)

Parallelized Explicit Extrapolation Method. Euler extrapolation using Barycentric coordinates, following Hairer's SODEX in the adaptivity behavior.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ImplicitEulerBarycentricExtrapolation(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • max_order: maximum order of the adaptive order algorithm.
  • min_order: minimum order of the adaptive order algorithm.
  • init_order: initial order of the adaptive order algorithm.
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • sequence: the step-number sequences, also called the subdividing sequence. Possible values are :harmonic, :romberg or :bulirsch.
  • sequence_factor: denotes which even multiple of sequence to take while evaluating internal discretizations.

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
+ sequence_factor = 2)

Parallelized Explicit Extrapolation Method. Euler extrapolation using Barycentric coordinates, following Hairer's SODEX in the adaptivity behavior.

Keyword Arguments

References

@inproceedings{elrod2022parallelizing, title={Parallelizing explicit and implicit extrapolation methods for ordinary differential equations}, author={Elrod, Chris and Ma, Yingbo and Althaus, Konstantin and Rackauckas, Christopher and others}, booktitle={2022 IEEE High Performance Extreme Computing Conference (HPEC)}, pages={1–9}, year={2022}, organization={IEEE}}

source
diff --git a/dev/implicit/FIRK/index.html b/dev/implicit/FIRK/index.html index 62669ab3e5..49ca2ad012 100644 --- a/dev/implicit/FIRK/index.html +++ b/dev/implicit/FIRK/index.html @@ -23,7 +23,7 @@ precs = DEFAULT_PRECS, extrapolant = :dense, smooth_est = true, - step_limiter! = trivial_limiter!)

Fully-Implicit Runge-Kutta Method. An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency. Similar to Hairer's SEULEX.

Keyword Arguments

References

@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}}

source
OrdinaryDiffEqFIRK.RadauIIA5 — Type
RadauIIA5(; chunk_size = Val{0}(),
+            step_limiter! = trivial_limiter!)

Fully-Implicit Runge-Kutta Method. An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency. Similar to Hairer's SEULEX.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify RadauIIA3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • extrapolant: TBD
  • smooth_est: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}}

source
OrdinaryDiffEqFIRK.RadauIIA5 — Type
RadauIIA5(; chunk_size = Val{0}(),
             autodiff = true,
             standardtag = Val{true}(),
             concrete_jac = nothing,
@@ -32,7 +32,7 @@
             precs = DEFAULT_PRECS,
             extrapolant = :dense,
             smooth_est = true,
-            step_limiter! = trivial_limiter!)

Fully-Implicit Runge-Kutta Method. An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency. Similar to Hairer's SEULEX.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify RadauIIA5(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • extrapolant: TBD
  • smooth_est: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}}

source
OrdinaryDiffEqFIRK.RadauIIA9 — Type
RadauIIA9(; chunk_size = Val{0}(),
+            step_limiter! = trivial_limiter!)

Fully-Implicit Runge-Kutta Method. An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency. Similar to Hairer's SEULEX.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify RadauIIA5(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • extrapolant: TBD
  • smooth_est: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}}

source
OrdinaryDiffEqFIRK.RadauIIA9 — Type
RadauIIA9(; chunk_size = Val{0}(),
             autodiff = true,
             standardtag = Val{true}(),
             concrete_jac = nothing,
@@ -41,4 +41,4 @@
             precs = DEFAULT_PRECS,
             extrapolant = :dense,
             smooth_est = true,
-            step_limiter! = trivial_limiter!)

Fully-Implicit Runge-Kutta Method. An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency. Similar to Hairer's SEULEX.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify RadauIIA9(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • extrapolant: TBD
  • smooth_est: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}}

source
+ step_limiter! = trivial_limiter!)

Fully-Implicit Runge-Kutta Method. An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency. Similar to Hairer's SEULEX.

Keyword Arguments

References

@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}}

source
diff --git a/dev/implicit/Nordsieck/index.html b/dev/implicit/Nordsieck/index.html index 6542967ba1..90c3e1e492 100644 --- a/dev/implicit/Nordsieck/index.html +++ b/dev/implicit/Nordsieck/index.html @@ -14,4 +14,4 @@ u0 = [1.0; 0.0; 0.0] tspan = (0.0, 100.0) prob = ODEProblem(lorenz!, u0, tspan) -sol = solve(prob, AN5())

Full list of solvers

OrdinaryDiffEqNordsieck.AN5 — Type
AN5()

Adaptive step size Adams explicit Method An adaptive 5th order fixed-leading coefficient Adams method in Nordsieck form.

Experimental

AN5 is experimental, the solver VCABM is generally preferred.

Keyword Arguments

References

source
OrdinaryDiffEqNordsieck.JVODE — Type
Experimental

JVODE is experimental, the solver VCABM is generally preferred.

source
OrdinaryDiffEqNordsieck.JVODE_Adams — Function
Experimental

JVODE is experimental, the solver VCABM is generally preferred.

source
OrdinaryDiffEqNordsieck.JVODE_BDF — Function
Experimental

JVODE is experimental, the solver FBDF is generally preferred.

source
+sol = solve(prob, AN5())

Full list of solvers

OrdinaryDiffEqNordsieck.AN5 — Type
AN5()

Adaptive step size Adams explicit Method An adaptive 5th order fixed-leading coefficient Adams method in Nordsieck form.

Experimental

AN5 is experimental, the solver VCABM is generally preferred.

Keyword Arguments

References

source
OrdinaryDiffEqNordsieck.JVODE — Type
Experimental

JVODE is experimental, the solver VCABM is generally preferred.

source
OrdinaryDiffEqNordsieck.JVODE_Adams — Function
Experimental

JVODE is experimental, the solver VCABM is generally preferred.

source
OrdinaryDiffEqNordsieck.JVODE_BDF — Function
Experimental

JVODE is experimental, the solver FBDF is generally preferred.

source
diff --git a/dev/implicit/PDIRK/index.html b/dev/implicit/PDIRK/index.html index fde27e577a..f853c922a8 100644 --- a/dev/implicit/PDIRK/index.html +++ b/dev/implicit/PDIRK/index.html @@ -23,4 +23,4 @@ precs = DEFAULT_PRECS, nlsolve = NLNewton(), extrapolant = :constant, - thread = OrdinaryDiffEq.True())

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

Keyword Arguments

References

"@article{iserles1990theory, title={On the theory of parallel Runge—Kutta methods}, author={Iserles, Arieh and Norrsett, SP}, journal={IMA Journal of numerical Analysis}, volume={10}, number={4}, pages={463–488}, year={1990}, publisher={Oxford University Press}}

source
+ thread = OrdinaryDiffEq.True())

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

Keyword Arguments

References

"@article{iserles1990theory, title={On the theory of parallel Runge—Kutta methods}, author={Iserles, Arieh and Norrsett, SP}, journal={IMA Journal of numerical Analysis}, volume={10}, number={4}, pages={463–488}, year={1990}, publisher={Oxford University Press}}

source
diff --git a/dev/implicit/SDIRK/index.html b/dev/implicit/SDIRK/index.html index a93b0b8797..bd793d53d7 100644 --- a/dev/implicit/SDIRK/index.html +++ b/dev/implicit/SDIRK/index.html @@ -24,7 +24,7 @@ nlsolve = NLNewton(), extrapolant = :constant, controller = :PI, - step_limiter! = trivial_limiter!)

SDIRK Method. A 1st order implicit solver. A-B-L-stable. Adaptive timestepping through a divided differences estimate via memory. Strong-stability preserving (SSP).

Keyword Arguments

References

@book{wanner1996solving, title={Solving ordinary differential equations II}, author={Wanner, Gerhard and Hairer, Ernst}, volume={375}, year={1996}, publisher={Springer Berlin Heidelberg New York}}

source
OrdinaryDiffEqSDIRK.ImplicitMidpoint — Type
ImplicitMidpoint(; chunk_size = Val{0}(),
+                step_limiter! = trivial_limiter!)

SDIRK Method. A 1st order implicit solver. A-B-L-stable. Adaptive timestepping through a divided differences estimate via memory. Strong-stability preserving (SSP).

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ImplicitEuler(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@book{wanner1996solving, title={Solving ordinary differential equations II}, author={Wanner, Gerhard and Hairer, Ernst}, volume={375}, year={1996}, publisher={Springer Berlin Heidelberg New York}}

source
OrdinaryDiffEqSDIRK.ImplicitMidpoint — Type
ImplicitMidpoint(; chunk_size = Val{0}(),
                    autodiff = true,
                    standardtag = Val{true}(),
                    concrete_jac = nothing,
@@ -33,7 +33,7 @@
                    precs = DEFAULT_PRECS,
                    nlsolve = NLNewton(),
                    extrapolant = :linear,
-                   step_limiter! = trivial_limiter!)

SDIRK Method. A second order A-stable symplectic and symmetric implicit solver. Good for highly stiff equations which need symplectic integration.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ImplicitMidpoint(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@book{wanner1996solving, title={Solving ordinary differential equations II}, author={Wanner, Gerhard and Hairer, Ernst}, volume={375}, year={1996}, publisher={Springer Berlin Heidelberg New York}}

source
OrdinaryDiffEqSDIRK.Trapezoid — Type
Trapezoid(; chunk_size = Val{0}(),
+                   step_limiter! = trivial_limiter!)

SDIRK Method. A second order A-stable symplectic and symmetric implicit solver. Good for highly stiff equations which need symplectic integration.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ImplicitMidpoint(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@book{wanner1996solving, title={Solving ordinary differential equations II}, author={Wanner, Gerhard and Hairer, Ernst}, volume={375}, year={1996}, publisher={Springer Berlin Heidelberg New York}}

source
OrdinaryDiffEqSDIRK.Trapezoid — Type
Trapezoid(; chunk_size = Val{0}(),
             autodiff = true,
             standardtag = Val{true}(),
             concrete_jac = nothing,
@@ -43,7 +43,7 @@
             nlsolve = NLNewton(),
             extrapolant = :linear,
             controller = :PI,
-            step_limiter! = trivial_limiter!)

SDIRK Method. 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).

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Trapezoid(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

Andre Vladimirescu. 1994. The Spice Book. John Wiley & Sons, Inc., New York, NY, USA.

source
OrdinaryDiffEqSDIRK.TRBDF2 — Type
TRBDF2(; chunk_size = Val{0}(),
+            step_limiter! = trivial_limiter!)

SDIRK Method. 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).

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Trapezoid(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

Andre Vladimirescu. 1994. The Spice Book. John Wiley & Sons, Inc., New York, NY, USA.

source
OrdinaryDiffEqSDIRK.TRBDF2 — Type
TRBDF2(; chunk_size = Val{0}(),
          autodiff = true,
          standardtag = Val{true}(),
          concrete_jac = nothing,
@@ -54,7 +54,7 @@
          smooth_est = true,
          extrapolant = :linear,
          controller = :PI,
-         step_limiter! = trivial_limiter!)

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.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify TRBDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}

source
OrdinaryDiffEqSDIRK.SDIRK2 — Type
SDIRK2(; chunk_size = Val{0}(),
+         step_limiter! = trivial_limiter!)

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.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify TRBDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}

source
OrdinaryDiffEqSDIRK.SDIRK2 — Type
SDIRK2(; chunk_size = Val{0}(),
          autodiff = true,
          standardtag = Val{true}(),
          concrete_jac = nothing,
@@ -65,7 +65,7 @@
          smooth_est = true,
          extrapolant = :linear,
          controller = :PI,
-         step_limiter! = trivial_limiter!)

SDIRK Method. SDIRK2: SDIRK Method An A-B-L stable 2nd order SDIRK method

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SDIRK2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}}

source
OrdinaryDiffEqSDIRK.SDIRK22 — Type
SDIRK22(; chunk_size = Val{0}(),
+         step_limiter! = trivial_limiter!)

SDIRK Method. SDIRK2: SDIRK Method An A-B-L stable 2nd order SDIRK method

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SDIRK2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}}

source
OrdinaryDiffEqSDIRK.SDIRK22 — Type
SDIRK22(; chunk_size = Val{0}(),
           autodiff = true,
           standardtag = Val{true}(),
           concrete_jac = nothing,
@@ -76,7 +76,7 @@
           smooth_est = true,
           extrapolant = :linear,
           controller = :PI,
-          step_limiter! = trivial_limiter!)

SDIRK Method. Description TBD

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SDIRK22(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@techreport{kennedy2016diagonally, title={Diagonally implicit Runge-Kutta methods for ordinary differential equations. A review}, author={Kennedy, Christopher A and Carpenter, Mark H}, year={2016}}

source
OrdinaryDiffEqSDIRK.SSPSDIRK2 — Type
SSPSDIRK2(; chunk_size = Val{0}(),
+          step_limiter! = trivial_limiter!)

SDIRK Method. Description TBD

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SDIRK22(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@techreport{kennedy2016diagonally, title={Diagonally implicit Runge-Kutta methods for ordinary differential equations. A review}, author={Kennedy, Christopher A and Carpenter, Mark H}, year={2016}}

source
OrdinaryDiffEqSDIRK.SSPSDIRK2 — Type
SSPSDIRK2(; chunk_size = Val{0}(),
             autodiff = true,
             standardtag = Val{true}(),
             concrete_jac = nothing,
@@ -86,7 +86,7 @@
             nlsolve = NLNewton(),
             smooth_est = true,
             extrapolant = :constant,
-            controller = :PI)

SDIRK Method. SSPSDIRK is an SSP-optimized SDIRK method, so it's an implicit SDIRK method for handling stiffness but if the dt is below the SSP coefficient * dt, then the SSP property of the SSP integrators (the other page) is satisified. As such this is a method which is expected to be good on advection-dominated cases where an explicit SSP integrator would be used, but where reaction equations are sufficient stiff to justify implicit integration.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SSPSDIRK2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD

References

@article{ketcheson2009optimal, title={Optimal implicit strong stability preserving Runge–Kutta methods}, author={Ketcheson, David I and Macdonald, Colin B and Gottlieb, Sigal}, journal={Applied Numerical Mathematics}, volume={59}, number={2}, pages={373–392}, year={2009}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.Kvaerno3 — Type
Kvaerno3(; chunk_size = Val{0}(),
+            controller = :PI)

SDIRK Method. SSPSDIRK is an SSP-optimized SDIRK method, so it's an implicit SDIRK method for handling stiffness but if the dt is below the SSP coefficient * dt, then the SSP property of the SSP integrators (the other page) is satisified. As such this is a method which is expected to be good on advection-dominated cases where an explicit SSP integrator would be used, but where reaction equations are sufficient stiff to justify implicit integration.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SSPSDIRK2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD

References

@article{ketcheson2009optimal, title={Optimal implicit strong stability preserving Runge–Kutta methods}, author={Ketcheson, David I and Macdonald, Colin B and Gottlieb, Sigal}, journal={Applied Numerical Mathematics}, volume={59}, number={2}, pages={373–392}, year={2009}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.Kvaerno3 — Type
Kvaerno3(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -97,7 +97,7 @@
            smooth_est = true,
            extrapolant = :linear,
            controller = :PI,
-           step_limiter! = trivial_limiter!)

SDIRK Method. An A-L stable stiffly-accurate 3rd order ESDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Kvaerno3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}}

source
OrdinaryDiffEqSDIRK.KenCarp3 — Type
KenCarp3(; chunk_size = Val{0}(),
+           step_limiter! = trivial_limiter!)

SDIRK Method. An A-L stable stiffly-accurate 3rd order ESDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Kvaerno3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}}

source
OrdinaryDiffEqSDIRK.KenCarp3 — Type
KenCarp3(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -108,7 +108,7 @@
            smooth_est = true,
            extrapolant = :linear,
            controller = :PI,
-           step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify KenCarp3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}}

source
OrdinaryDiffEqSDIRK.CFNLIRK3 — Type
CFNLIRK3(; chunk_size = Val{0}(),
+           step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify KenCarp3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@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}}

source
OrdinaryDiffEqSDIRK.CFNLIRK3 — Type
CFNLIRK3(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -116,7 +116,7 @@
            linsolve = nothing,
            precs = DEFAULT_PRECS,
            nlsolve = NLNewton(),
-           extrapolant = :linear)

SDIRK Method. Third order method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify CFNLIRK3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{calvo2001linearly, title={Linearly implicit Runge–Kutta methods for advection–reaction–diffusion equations}, author={Calvo, MP and De Frutos, J and Novo, J}, journal={Applied Numerical Mathematics}, volume={37}, number={4}, pages={535–549}, year={2001}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.Cash4 — Type
Cash4(; chunk_size = Val{0}(),
+           extrapolant = :linear)

SDIRK Method. Third order method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify CFNLIRK3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{calvo2001linearly, title={Linearly implicit Runge–Kutta methods for advection–reaction–diffusion equations}, author={Calvo, MP and De Frutos, J and Novo, J}, journal={Applied Numerical Mathematics}, volume={37}, number={4}, pages={535–549}, year={2001}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.Cash4 — Type
Cash4(; chunk_size = Val{0}(),
         autodiff = true,
         standardtag = Val{true}(),
         concrete_jac = nothing,
@@ -127,7 +127,7 @@
         smooth_est = true,
         extrapolant = :linear,
         controller = :PI,
-        embedding = 3)

SDIRK Method. An A-L stable 4th order SDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Cash4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • embedding: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.SFSDIRK4 — Type
SFSDIRK4(; chunk_size = Val{0}(),
+        embedding = 3)

SDIRK Method. An A-L stable 4th order SDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Cash4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • embedding: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.SFSDIRK4 — Type
SFSDIRK4(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -135,7 +135,7 @@
            linsolve = nothing,
            precs = DEFAULT_PRECS,
            nlsolve = NLNewton(),
-           extrapolant = :linear)

SDIRK Method. Method of order 4.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SFSDIRK4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{ferracina2008strong, title={Strong stability of singly-diagonally-implicit Runge–Kutta methods}, author={Ferracina, Luca and Spijker, MN}, journal={Applied Numerical Mathematics}, volume={58}, number={11}, pages={1675–1686}, year={2008}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.SFSDIRK5 — Type
SFSDIRK5(; chunk_size = Val{0}(),
+           extrapolant = :linear)

SDIRK Method. Method of order 4.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SFSDIRK4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{ferracina2008strong, title={Strong stability of singly-diagonally-implicit Runge–Kutta methods}, author={Ferracina, Luca and Spijker, MN}, journal={Applied Numerical Mathematics}, volume={58}, number={11}, pages={1675–1686}, year={2008}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.SFSDIRK5 — Type
SFSDIRK5(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -143,7 +143,7 @@
            linsolve = nothing,
            precs = DEFAULT_PRECS,
            nlsolve = NLNewton(),
-           extrapolant = :linear)

SDIRK Method. Method of order 5.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SFSDIRK5(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{ferracina2008strong, title={Strong stability of singly-diagonally-implicit Runge–Kutta methods}, author={Ferracina, Luca and Spijker, MN}, journal={Applied Numerical Mathematics}, volume={58}, number={11}, pages={1675–1686}, year={2008}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.SFSDIRK6 — Type
SFSDIRK6(; chunk_size = Val{0}(),
+           extrapolant = :linear)

SDIRK Method. Method of order 5.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SFSDIRK5(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{ferracina2008strong, title={Strong stability of singly-diagonally-implicit Runge–Kutta methods}, author={Ferracina, Luca and Spijker, MN}, journal={Applied Numerical Mathematics}, volume={58}, number={11}, pages={1675–1686}, year={2008}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.SFSDIRK6 — Type
SFSDIRK6(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -151,7 +151,7 @@
            linsolve = nothing,
            precs = DEFAULT_PRECS,
            nlsolve = NLNewton(),
-           extrapolant = :linear)

SDIRK Method. Method of order 6.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SFSDIRK6(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{ferracina2008strong, title={Strong stability of singly-diagonally-implicit Runge–Kutta methods}, author={Ferracina, Luca and Spijker, MN}, journal={Applied Numerical Mathematics}, volume={58}, number={11}, pages={1675–1686}, year={2008}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.SFSDIRK7 — Type
SFSDIRK7(; chunk_size = Val{0}(),
+           extrapolant = :linear)

SDIRK Method. Method of order 6.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SFSDIRK6(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{ferracina2008strong, title={Strong stability of singly-diagonally-implicit Runge–Kutta methods}, author={Ferracina, Luca and Spijker, MN}, journal={Applied Numerical Mathematics}, volume={58}, number={11}, pages={1675–1686}, year={2008}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.SFSDIRK7 — Type
SFSDIRK7(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -159,7 +159,7 @@
            linsolve = nothing,
            precs = DEFAULT_PRECS,
            nlsolve = NLNewton(),
-           extrapolant = :linear)

SDIRK Method. Method of order 7.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SFSDIRK7(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{ferracina2008strong, title={Strong stability of singly-diagonally-implicit Runge–Kutta methods}, author={Ferracina, Luca and Spijker, MN}, journal={Applied Numerical Mathematics}, volume={58}, number={11}, pages={1675–1686}, year={2008}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.SFSDIRK8 — Type
SFSDIRK8(; chunk_size = Val{0}(),
+           extrapolant = :linear)

SDIRK Method. Method of order 7.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SFSDIRK7(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{ferracina2008strong, title={Strong stability of singly-diagonally-implicit Runge–Kutta methods}, author={Ferracina, Luca and Spijker, MN}, journal={Applied Numerical Mathematics}, volume={58}, number={11}, pages={1675–1686}, year={2008}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.SFSDIRK8 — Type
SFSDIRK8(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -167,7 +167,7 @@
            linsolve = nothing,
            precs = DEFAULT_PRECS,
            nlsolve = NLNewton(),
-           extrapolant = :linear)

SDIRK Method. Method of order 8.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SFSDIRK8(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{ferracina2008strong, title={Strong stability of singly-diagonally-implicit Runge–Kutta methods}, author={Ferracina, Luca and Spijker, MN}, journal={Applied Numerical Mathematics}, volume={58}, number={11}, pages={1675–1686}, year={2008}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.Hairer4 — Type
Hairer4(; chunk_size = Val{0}(),
+           extrapolant = :linear)

SDIRK Method. Method of order 8.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify SFSDIRK8(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD

References

@article{ferracina2008strong, title={Strong stability of singly-diagonally-implicit Runge–Kutta methods}, author={Ferracina, Luca and Spijker, MN}, journal={Applied Numerical Mathematics}, volume={58}, number={11}, pages={1675–1686}, year={2008}, publisher={Elsevier}}

source
OrdinaryDiffEqSDIRK.Hairer4 — Type
Hairer4(; chunk_size = Val{0}(),
           autodiff = true,
           standardtag = Val{true}(),
           concrete_jac = nothing,
@@ -177,7 +177,7 @@
           nlsolve = NLNewton(),
           smooth_est = true,
           extrapolant = :linear,
-          controller = :PI)

SDIRK Method. An A-L stable 4th order SDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Hairer4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD

References

E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)

source
OrdinaryDiffEqSDIRK.Hairer42 — Type
Hairer42(; chunk_size = Val{0}(),
+          controller = :PI)

SDIRK Method. An A-L stable 4th order SDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Hairer4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD

References

E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)

source
OrdinaryDiffEqSDIRK.Hairer42 — Type
Hairer42(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -187,7 +187,7 @@
            nlsolve = NLNewton(),
            smooth_est = true,
            extrapolant = :linear,
-           controller = :PI)

SDIRK Method. An A-L stable 4th order SDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Hairer42(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD

References

E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)

source
OrdinaryDiffEqSDIRK.Kvaerno4 — Type
Kvaerno4(; chunk_size = Val{0}(),
+           controller = :PI)

SDIRK Method. An A-L stable 4th order SDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Hairer42(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD

References

E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)

source
OrdinaryDiffEqSDIRK.Kvaerno4 — Type
Kvaerno4(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -198,7 +198,7 @@
            smooth_est = true,
            extrapolant = :linear,
            controller = :PI,
-           step_limiter! = trivial_limiter!)

SDIRK Method. An A-L stable stiffly-accurate 4th order ESDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Kvaerno4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.Kvaerno5 — Type
Kvaerno5(; chunk_size = Val{0}(),
+           step_limiter! = trivial_limiter!)

SDIRK Method. An A-L stable stiffly-accurate 4th order ESDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Kvaerno4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.Kvaerno5 — Type
Kvaerno5(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -209,7 +209,7 @@
            smooth_est = true,
            extrapolant = :linear,
            controller = :PI,
-           step_limiter! = trivial_limiter!)

SDIRK Method. An A-L stable stiffly-accurate 5th order ESDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Kvaerno5(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter: TBD

References

@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}}

source

IMEX SDIRK

OrdinaryDiffEqSDIRK.KenCarp4 — Type
KenCarp4(; chunk_size = Val{0}(),
+           step_limiter! = trivial_limiter!)

SDIRK Method. An A-L stable stiffly-accurate 5th order ESDIRK method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Kvaerno5(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter: TBD

References

@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}}

source

IMEX SDIRK

OrdinaryDiffEqSDIRK.KenCarp4 — Type
KenCarp4(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -220,7 +220,7 @@
            smooth_est = true,
            extrapolant = :linear,
            controller = :PI,
-           step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify KenCarp4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.KenCarp47 — Type
KenCarp47(; chunk_size = Val{0}(),
+           step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify KenCarp4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.KenCarp47 — Type
KenCarp47(; chunk_size = Val{0}(),
             autodiff = true,
             standardtag = Val{true}(),
             concrete_jac = nothing,
@@ -230,7 +230,7 @@
             nlsolve = NLNewton(),
             smooth_est = true,
             extrapolant = :linear,
-            controller = :PI)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify KenCarp47(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.KenCarp5 — Type
KenCarp5(; chunk_size = Val{0}(),
+            controller = :PI)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify KenCarp47(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.KenCarp5 — Type
KenCarp5(; chunk_size = Val{0}(),
            autodiff = true,
            standardtag = Val{true}(),
            concrete_jac = nothing,
@@ -241,7 +241,7 @@
            smooth_est = true,
            extrapolant = :linear,
            controller = :PI,
-           step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify KenCarp5(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.KenCarp58 — Type
KenCarp58(; chunk_size = Val{0}(),
+           step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify KenCarp5(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.KenCarp58 — Type
KenCarp58(; chunk_size = Val{0}(),
             autodiff = true,
             standardtag = Val{true}(),
             concrete_jac = nothing,
@@ -251,7 +251,7 @@
             nlsolve = NLNewton(),
             smooth_est = true,
             extrapolant = :linear,
-            controller = :PI)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify KenCarp58(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.ESDIRK54I8L2SA — Type
ESDIRK54I8L2SA(; chunk_size = Val{0}(),
+            controller = :PI)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify KenCarp58(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD

References

@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}}

source
OrdinaryDiffEqSDIRK.ESDIRK54I8L2SA — Type
ESDIRK54I8L2SA(; chunk_size = Val{0}(),
                  autodiff = true,
                  standardtag = Val{true}(),
                  concrete_jac = nothing,
@@ -260,7 +260,7 @@
                  precs = DEFAULT_PRECS,
                  nlsolve = NLNewton(),
                  extrapolant = :linear,
-                 controller = :PI)

SDIRK Method. Optimized ESDIRK tableaus. Updates of the original KenCarp tableau expected to achieve lower error for the same steps in theory, but are still being fully evaluated in context.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ESDIRK54I8L2SA(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD

References

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

source
OrdinaryDiffEqSDIRK.ESDIRK436L2SA2 — Type
ESDIRK436L2SA2(; chunk_size = Val{0}(),
+                 controller = :PI)

SDIRK Method. Optimized ESDIRK tableaus. Updates of the original KenCarp tableau expected to achieve lower error for the same steps in theory, but are still being fully evaluated in context.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ESDIRK54I8L2SA(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD

References

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

source
OrdinaryDiffEqSDIRK.ESDIRK436L2SA2 — Type
ESDIRK436L2SA2(; chunk_size = Val{0}(),
                  autodiff = true,
                  standardtag = Val{true}(),
                  concrete_jac = nothing,
@@ -269,7 +269,7 @@
                  precs = DEFAULT_PRECS,
                  nlsolve = NLNewton(),
                  extrapolant = :linear,
-                 controller = :PI)

SDIRK Method. Optimized ESDIRK tableaus. Updates of the original KenCarp tableau expected to achieve lower error for the same steps in theory, but are still being fully evaluated in context.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ESDIRK436L2SA2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD

References

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

source
OrdinaryDiffEqSDIRK.ESDIRK437L2SA — Type
ESDIRK437L2SA(; chunk_size = Val{0}(),
+                 controller = :PI)

SDIRK Method. Optimized ESDIRK tableaus. Updates of the original KenCarp tableau expected to achieve lower error for the same steps in theory, but are still being fully evaluated in context.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ESDIRK436L2SA2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD

References

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

source
OrdinaryDiffEqSDIRK.ESDIRK437L2SA — Type
ESDIRK437L2SA(; chunk_size = Val{0}(),
                 autodiff = true,
                 standardtag = Val{true}(),
                 concrete_jac = nothing,
@@ -278,7 +278,7 @@
                 precs = DEFAULT_PRECS,
                 nlsolve = NLNewton(),
                 extrapolant = :linear,
-                controller = :PI)

SDIRK Method. Optimized ESDIRK tableaus. Updates of the original KenCarp tableau expected to achieve lower error for the same steps in theory, but are still being fully evaluated in context.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ESDIRK437L2SA(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD

References

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

source
OrdinaryDiffEqSDIRK.ESDIRK547L2SA2 — Type
ESDIRK547L2SA2(; chunk_size = Val{0}(),
+                controller = :PI)

SDIRK Method. Optimized ESDIRK tableaus. Updates of the original KenCarp tableau expected to achieve lower error for the same steps in theory, but are still being fully evaluated in context.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ESDIRK437L2SA(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD

References

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

source
OrdinaryDiffEqSDIRK.ESDIRK547L2SA2 — Type
ESDIRK547L2SA2(; chunk_size = Val{0}(),
                  autodiff = true,
                  standardtag = Val{true}(),
                  concrete_jac = nothing,
@@ -287,7 +287,7 @@
                  precs = DEFAULT_PRECS,
                  nlsolve = NLNewton(),
                  extrapolant = :linear,
-                 controller = :PI)

SDIRK Method. Optimized ESDIRK tableaus. Updates of the original KenCarp tableau expected to achieve lower error for the same steps in theory, but are still being fully evaluated in context.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ESDIRK547L2SA2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD

References

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

source
OrdinaryDiffEqSDIRK.ESDIRK659L2SA — Type
ESDIRK659L2SA(; chunk_size = Val{0}(),
+                 controller = :PI)

SDIRK Method. Optimized ESDIRK tableaus. Updates of the original KenCarp tableau expected to achieve lower error for the same steps in theory, but are still being fully evaluated in context.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ESDIRK547L2SA2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD

References

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

source
OrdinaryDiffEqSDIRK.ESDIRK659L2SA — Type
ESDIRK659L2SA(; chunk_size = Val{0}(),
                 autodiff = true,
                 standardtag = Val{true}(),
                 concrete_jac = nothing,
@@ -296,4 +296,4 @@
                 precs = DEFAULT_PRECS,
                 nlsolve = NLNewton(),
                 extrapolant = :linear,
-                controller = :PI)

SDIRK Method. Optimized ESDIRK tableaus. Updates of the original KenCarp tableau expected to achieve lower error for the same steps in theory, but are still being fully evaluated in context. Currently has STABILITY ISSUES, causing it to fail the adaptive tests. Check issue https://github.com/SciML/OrdinaryDiffEq.jl/issues/1933 for more details.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ESDIRK659L2SA(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • nlsolve: TBD
    • extrapolant: TBD
  • controller: TBD

References

@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
+ controller = :PI)

SDIRK Method. Optimized ESDIRK tableaus. Updates of the original KenCarp tableau expected to achieve lower error for the same steps in theory, but are still being fully evaluated in context. Currently has STABILITY ISSUES, causing it to fail the adaptive tests. Check issue https://github.com/SciML/OrdinaryDiffEq.jl/issues/1933 for more details.

Keyword Arguments

References

@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
diff --git a/dev/index.html b/dev/index.html index eff438aa75..b9fcc633e5 100644 --- a/dev/index.html +++ b/dev/index.html @@ -177,7 +177,7 @@ [0bca4576] SciMLBase v2.62.0 [19f34311] SciMLJacobianOperators v0.1.1 [c0aeaf25] SciMLOperators v0.3.12 - [53ae85a6] SciMLStructures v1.6.0 + [53ae85a6] SciMLStructures v1.6.1 [efcf1570] Setfield v1.1.1 [727e6d20] SimpleNonlinearSolve v2.0.0 [699a6c99] SimpleTraits v0.9.4 @@ -269,4 +269,4 @@ [8e850b90] libblastrampoline_jll v5.11.0+0 [8e850ede] nghttp2_jll v1.59.0+0 [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 manifest file and the project file.

+Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m`

You can also download the manifest file and the project file.

diff --git a/dev/massmatrixdae/BDF/index.html b/dev/massmatrixdae/BDF/index.html index aa05f8edc7..17852ff9ed 100644 --- a/dev/massmatrixdae/BDF/index.html +++ b/dev/massmatrixdae/BDF/index.html @@ -29,7 +29,7 @@ smooth_est = true, extrapolant = :linear, controller = :Standard, - step_limiter! = trivial_limiter!)

Multistep Method. An adaptive order 2 L-stable fixed leading coefficient multistep BDF method.

Keyword Arguments

References

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

source
OrdinaryDiffEqBDF.QNDF — Type
QNDF(; chunk_size = Val{0}(),
+        step_limiter! = trivial_limiter!)

Multistep Method. An adaptive order 2 L-stable fixed leading coefficient multistep BDF method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ABDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- κ: TBD
  • tol: TBD
  • nlsolve: TBD
  • smooth_est: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEqBDF.QNDF — Type
QNDF(; chunk_size = Val{0}(),
        autodiff = true,
        standardtag = Val{true}(),
        concrete_jac = nothing,
@@ -42,7 +42,7 @@
        extrapolant = :linear,
        kappa =  promote(-0.1850, -1 // 9, -0.0823, -0.0415, 0),
        controller = :Standard,
-       step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- κ: TBD
  • tol: TBD
  • nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QNDF1 — Type
QNDF1(; chunk_size = Val{0}(),
+       step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- κ: TBD
  • tol: TBD
  • nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QNDF1 — Type
QNDF1(; chunk_size = Val{0}(),
         autodiff = true,
         standardtag = Val{true}(),
         concrete_jac = nothing,
@@ -53,7 +53,7 @@
         extrapolant = :linear,
         kappa = -0.1850,
         controller = :Standard,
-        step_limiter! = trivial_limiter!)

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.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF1(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QNDF2 — Type
QNDF2(; chunk_size = Val{0}(),
+        step_limiter! = trivial_limiter!)

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.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF1(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QNDF2 — Type
QNDF2(; chunk_size = Val{0}(),
         autodiff = true,
         standardtag = Val{true}(),
         concrete_jac = nothing,
@@ -64,7 +64,7 @@
         extrapolant = :linear,
         kappa =  -1 // 9,
         controller = :Standard,
-        step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QBDF — Function

QBDF: Multistep Method

An alias of QNDF with κ=0.

source
OrdinaryDiffEqBDF.QBDF1 — Function

QBDF1: Multistep Method

An alias of QNDF1 with κ=0.

source
OrdinaryDiffEqBDF.QBDF2 — Function

QBDF2: Multistep Method

An alias of QNDF2 with κ=0.

source
OrdinaryDiffEqBDF.MEBDF2 — Type
MEBDF2(; chunk_size = Val{0}(),
+        step_limiter! = trivial_limiter!)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify QNDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD
  • kappa: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

source
OrdinaryDiffEqBDF.QBDF — Function

QBDF: Multistep Method

An alias of QNDF with κ=0.

source
OrdinaryDiffEqBDF.QBDF1 — Function

QBDF1: Multistep Method

An alias of QNDF1 with κ=0.

source
OrdinaryDiffEqBDF.QBDF2 — Function

QBDF2: Multistep Method

An alias of QNDF2 with κ=0.

source
OrdinaryDiffEqBDF.MEBDF2 — Type
MEBDF2(; chunk_size = Val{0}(),
          autodiff = true,
          standardtag = Val{true}(),
          concrete_jac = nothing,
@@ -72,7 +72,7 @@
          linsolve = nothing,
          precs = DEFAULT_PRECS,
          nlsolve = NLNewton(),
-         extrapolant = :constant)

Multistep Method. The second order Modified Extended BDF method, which has improved stability properties over the standard BDF. Fixed timestep only.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify MEBDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD

References

@article{cash2000modified, title={Modified extended backward differentiation formulae for the numerical solution of stiff initial value problems in ODEs and DAEs}, author={Cash, JR}, journal={Journal of Computational and Applied Mathematics}, volume={125}, number={1-2}, pages={117–130}, year={2000}, publisher={Elsevier}}

source
OrdinaryDiffEqBDF.FBDF — Type
FBDF(; chunk_size = Val{0}(),
+         extrapolant = :constant)

Multistep Method. The second order Modified Extended BDF method, which has improved stability properties over the standard BDF. Fixed timestep only.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify MEBDF2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- nlsolve: TBD
  • extrapolant: TBD

References

@article{cash2000modified, title={Modified extended backward differentiation formulae for the numerical solution of stiff initial value problems in ODEs and DAEs}, author={Cash, JR}, journal={Journal of Computational and Applied Mathematics}, volume={125}, number={1-2}, pages={117–130}, year={2000}, publisher={Elsevier}}

source
OrdinaryDiffEqBDF.FBDF — Type
FBDF(; chunk_size = Val{0}(),
        autodiff = true,
        standardtag = Val{true}(),
        concrete_jac = nothing,
@@ -85,4 +85,4 @@
        extrapolant = :linear,
        controller = :Standard,
        step_limiter! = trivial_limiter!,
-       max_order::Val{MO} = Val{5}())

Multistep Method. An adaptive order quasi-constant timestep NDF method. Fixed leading coefficient BDF. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients).

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify FBDF(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
    /n- κ: TBD
  • tol: TBD
  • nlsolve: TBD
  • extrapolant: TBD
  • controller: TBD
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • max_order: TBD

References

@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
+ max_order::Val{MO} = Val{5}())

Multistep Method. An adaptive order quasi-constant timestep NDF method. Fixed leading coefficient BDF. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients).

Keyword Arguments

References

@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/dev/massmatrixdae/Rosenbrock/index.html b/dev/massmatrixdae/Rosenbrock/index.html index d9bc61b3c4..cff56f4812 100644 --- a/dev/massmatrixdae/Rosenbrock/index.html +++ b/dev/massmatrixdae/Rosenbrock/index.html @@ -23,14 +23,14 @@ diff_type = Val{:central}, linsolve = nothing, precs = DEFAULT_PRECS, - step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

References

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

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

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rosenbrock23(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rosenbrock32 — Type
Rosenbrock32(; chunk_size = Val{0}(),
                standardtag = Val{true}(),
                autodiff = Val{true}(),
                concrete_jac = nothing,
                diff_type = Val{:central},
                linsolve = nothing,
                precs = DEFAULT_PRECS,
-               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rosenbrock32(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.ROS3P — Type
ROS3P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rosenbrock32(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.ROS3P — Type
ROS3P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
             and thus uses the internal ForwardDiff.jl algorithm for the choice.
         - `standardtag`: Specifies whether to use package-specific tags instead of the
             ForwardDiff default function-specific tags. For more information, see
@@ -84,7 +84,7 @@
           ```julia
           DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
           ```
-        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas3 — Type
Rodas3(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas3 — Type
Rodas3(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -138,14 +138,14 @@
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
            ```
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas23W — Type
Rodas23W(; chunk_size = Val{0}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas23W — Type
Rodas23W(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
            precs = DEFAULT_PRECS,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas23W(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas3P — Type
Rodas3P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas23W(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas3P — Type
Rodas3P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
               and thus uses the internal ForwardDiff.jl algorithm for the choice.
           - `standardtag`: Specifies whether to use package-specific tags instead of the
               ForwardDiff default function-specific tags. For more information, see
@@ -199,7 +199,7 @@
             ```julia
             DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
             ```
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4 — Type
Rodas4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4 — Type
Rodas4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -253,7 +253,7 @@
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
            ```
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas42 — Type
Rodas42(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas42 — Type
Rodas42(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
               and thus uses the internal ForwardDiff.jl algorithm for the choice.
           - `standardtag`: Specifies whether to use package-specific tags instead of the
               ForwardDiff default function-specific tags. For more information, see
@@ -307,7 +307,7 @@
             ```julia
             DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
             ```
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4P — Type
Rodas4P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4P — Type
Rodas4P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
               and thus uses the internal ForwardDiff.jl algorithm for the choice.
           - `standardtag`: Specifies whether to use package-specific tags instead of the
               ForwardDiff default function-specific tags. For more information, see
@@ -361,14 +361,14 @@
             ```julia
             DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
             ```
-          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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4P2 — Type
Rodas4P2(; chunk_size = Val{0}(),
+          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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4P2 — Type
Rodas4P2(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
            precs = DEFAULT_PRECS,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas4P2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas5 — Type
Rodas5(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas4P2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas5 — Type
Rodas5(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -422,34 +422,34 @@
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
            ```
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas5P — Type
Rodas5P(; chunk_size = Val{0}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas5P — Type
Rodas5P(; chunk_size = Val{0}(),
           standardtag = Val{true}(),
           autodiff = Val{true}(),
           concrete_jac = nothing,
           diff_type = Val{:central},
           linsolve = nothing,
           precs = DEFAULT_PRECS,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5P(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas5Pe — Type
Rodas5Pe(; chunk_size = Val{0}(),
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5P(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas5Pe — Type
Rodas5Pe(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
            precs = DEFAULT_PRECS,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5Pe(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Rosenbrock methods within OrdinaryDiffEq.jl - Overview, recent developments and applications - Preprint 2024 https://github.com/hbrs-cse/RosenbrockMethods/blob/main/paper/JuliaPaper.pdf
source
OrdinaryDiffEqRosenbrock.Rodas5Pr — Type
Rodas5Pr(; chunk_size = Val{0}(),
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5Pe(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Rosenbrock methods within OrdinaryDiffEq.jl - Overview, recent developments and applications - Preprint 2024 https://github.com/hbrs-cse/RosenbrockMethods/blob/main/paper/JuliaPaper.pdf
source
OrdinaryDiffEqRosenbrock.Rodas5Pr — Type
Rodas5Pr(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
            precs = DEFAULT_PRECS,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5Pr(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Rosenbrock methods within OrdinaryDiffEq.jl - Overview, recent developments and applications - Preprint 2024 https://github.com/hbrs-cse/RosenbrockMethods/blob/main/paper/JuliaPaper.pdf
source
OrdinaryDiffEqRosenbrock.RosenbrockW6S4OS — Type
RosenbrockW6S4OS(; chunk_size = Val{0}(),
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5Pr(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Rosenbrock methods within OrdinaryDiffEq.jl - Overview, recent developments and applications - Preprint 2024 https://github.com/hbrs-cse/RosenbrockMethods/blob/main/paper/JuliaPaper.pdf
source
OrdinaryDiffEqRosenbrock.RosenbrockW6S4OS — Type
RosenbrockW6S4OS(; chunk_size = Val{0}(),
                    standardtag = Val{true}(),
                    autodiff = Val{true}(),
                    concrete_jac = nothing,
                    diff_type = Val{:central},
                    linsolve = nothing,
-                   precs = DEFAULT_PRECS)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify RosenbrockW6S4OS(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

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

source
OrdinaryDiffEqRosenbrock.ROS2 — Type
ROS2(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+                   precs = DEFAULT_PRECS)

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

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify RosenbrockW6S4OS(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

https://doi.org/10.1016/j.cam.2009.09.017

source
OrdinaryDiffEqRosenbrock.ROS2 — Type
ROS2(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
            and thus uses the internal ForwardDiff.jl algorithm for the choice.
        - `standardtag`: Specifies whether to use package-specific tags instead of the
            ForwardDiff default function-specific tags. For more information, see
@@ -502,7 +502,7 @@
          is defined as:
          ```julia
          DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-         ```)

Rosenbrock-Wanner Method. A 2nd order L-stable Rosenbrock method with 2 internal stages.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS2PR — Type
ROS2PR(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+         ```)

Rosenbrock-Wanner Method. A 2nd order L-stable Rosenbrock method with 2 internal stages.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS2PR — Type
ROS2PR(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -555,13 +555,13 @@
            is defined as:
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-           ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS2S — Type
ROS2S(; chunk_size = Val{0}(),
+           ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS2S — Type
ROS2S(; chunk_size = Val{0}(),
         standardtag = Val{true}(),
         autodiff = Val{true}(),
         concrete_jac = nothing,
         diff_type = Val{:central},
         linsolve = nothing,
-        precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS2S(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

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
OrdinaryDiffEqRosenbrock.ROS3 — Type
ROS3(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+        precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS2S(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

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
OrdinaryDiffEqRosenbrock.ROS3 — Type
ROS3(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
            and thus uses the internal ForwardDiff.jl algorithm for the choice.
        - `standardtag`: Specifies whether to use package-specific tags instead of the
            ForwardDiff default function-specific tags. For more information, see
@@ -614,7 +614,7 @@
          is defined as:
          ```julia
          DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-         ```)

Rosenbrock-Wanner Method. 3rd order L-stable Rosenbrock method with 3 internal stages with an embedded strongly A-stable 2nd order method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS3PR — Type
ROS3PR(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+         ```)

Rosenbrock-Wanner Method. 3rd order L-stable Rosenbrock method with 3 internal stages with an embedded strongly A-stable 2nd order method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS3PR — Type
ROS3PR(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -667,7 +667,7 @@
            is defined as:
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-           ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Scholz4_7 — Type
Scholz4_7(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+           ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Scholz4_7 — Type
Scholz4_7(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
                 and thus uses the internal ForwardDiff.jl algorithm for the choice.
             - `standardtag`: Specifies whether to use package-specific tags instead of the
                 ForwardDiff default function-specific tags. For more information, see
@@ -720,37 +720,37 @@
               is defined as:
               ```julia
               DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-              ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS34PW1a — Type
ROS34PW1a(; chunk_size = Val{0}(),
+              ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS34PW1a — Type
ROS34PW1a(; chunk_size = Val{0}(),
             standardtag = Val{true}(),
             autodiff = Val{true}(),
             concrete_jac = nothing,
             diff_type = Val{:central},
             linsolve = nothing,
-            precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW1a(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW1b — Type
ROS34PW1b(; chunk_size = Val{0}(),
+            precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW1a(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW1b — Type
ROS34PW1b(; chunk_size = Val{0}(),
             standardtag = Val{true}(),
             autodiff = Val{true}(),
             concrete_jac = nothing,
             diff_type = Val{:central},
             linsolve = nothing,
-            precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW1b(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW2 — Type
ROS34PW2(; chunk_size = Val{0}(),
+            precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW1b(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW2 — Type
ROS34PW2(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
-           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order stiffy accurate Rosenbrock-W method for PDAEs.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW3 — Type
ROS34PW3(; chunk_size = Val{0}(),
+           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order stiffy accurate Rosenbrock-W method for PDAEs.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW3 — Type
ROS34PW3(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
-           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order strongly A-stable (Rinf~0.63) Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PRw — Type
ROS34PRw(; chunk_size = Val{0}(),
+           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order strongly A-stable (Rinf~0.63) Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PRw — Type
ROS34PRw(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
-           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PRw(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

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
OrdinaryDiffEqRosenbrock.ROS3PRL — Type
ROS3PRL(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PRw(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

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
OrdinaryDiffEqRosenbrock.ROS3PRL — Type
ROS3PRL(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
               and thus uses the internal ForwardDiff.jl algorithm for the choice.
           - `standardtag`: Specifies whether to use package-specific tags instead of the
               ForwardDiff default function-specific tags. For more information, see
@@ -803,7 +803,7 @@
             is defined as:
             ```julia
             DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-            ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS3PRL2 — Type
ROS3PRL2(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+            ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS3PRL2 — Type
ROS3PRL2(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
                and thus uses the internal ForwardDiff.jl algorithm for the choice.
            - `standardtag`: Specifies whether to use package-specific tags instead of the
                ForwardDiff default function-specific tags. For more information, see
@@ -856,13 +856,13 @@
              is defined as:
              ```julia
              DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-             ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROK4a — Type
ROK4a(; chunk_size = Val{0}(),
+             ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROK4a — Type
ROK4a(; chunk_size = Val{0}(),
         standardtag = Val{true}(),
         autodiff = Val{true}(),
         concrete_jac = nothing,
         diff_type = Val{:central},
         linsolve = nothing,
-        precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROK4a(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

  • Tranquilli, Paul and Sandu, Adrian (2014): Rosenbrock–Krylov Methods for Large Systems of Differential Equations https://doi.org/10.1137/130923336
source
OrdinaryDiffEqRosenbrock.RosShamp4 — Type
RosShamp4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+        precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROK4a(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

  • Tranquilli, Paul and Sandu, Adrian (2014): Rosenbrock–Krylov Methods for Large Systems of Differential Equations https://doi.org/10.1137/130923336
source
OrdinaryDiffEqRosenbrock.RosShamp4 — Type
RosShamp4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
                 and thus uses the internal ForwardDiff.jl algorithm for the choice.
             - `standardtag`: Specifies whether to use package-specific tags instead of the
                 ForwardDiff default function-specific tags. For more information, see
@@ -915,7 +915,7 @@
               is defined as:
               ```julia
               DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-              ```)

Rosenbrock-Wanner Method. An A-stable 4th order Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Veldd4 — Type
Veldd4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+              ```)

Rosenbrock-Wanner Method. An A-stable 4th order Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Veldd4 — Type
Veldd4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -969,14 +969,14 @@
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
            ```
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order D-stable Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Velds4 — Type
Velds4(; chunk_size = Val{0}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order D-stable Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Velds4 — Type
Velds4(; chunk_size = Val{0}(),
          standardtag = Val{true}(),
          autodiff = Val{true}(),
          concrete_jac = nothing,
          diff_type = Val{:central},
          linsolve = nothing,
          precs = DEFAULT_PRECS,
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order A-stable Rosenbrock method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Velds4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.GRK4T — Type
GRK4T(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order A-stable Rosenbrock method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Velds4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.GRK4T — Type
GRK4T(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
             and thus uses the internal ForwardDiff.jl algorithm for the choice.
         - `standardtag`: Specifies whether to use package-specific tags instead of the
             ForwardDiff default function-specific tags. For more information, see
@@ -1030,7 +1030,7 @@
           ```julia
           DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
           ```
-        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An efficient 4th order Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.GRK4A — Type
GRK4A(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An efficient 4th order Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.GRK4A — Type
GRK4A(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
             and thus uses the internal ForwardDiff.jl algorithm for the choice.
         - `standardtag`: Specifies whether to use package-specific tags instead of the
             ForwardDiff default function-specific tags. For more information, see
@@ -1084,7 +1084,7 @@
           ```julia
           DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
           ```
-        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An A-stable 4th order Rosenbrock method. Essentially "anti-L-stable" but efficient.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Ros4LStab — Type
Ros4LStab(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An A-stable 4th order Rosenbrock method. Essentially "anti-L-stable" but efficient.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Ros4LStab — Type
Ros4LStab(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
                 and thus uses the internal ForwardDiff.jl algorithm for the choice.
             - `standardtag`: Specifies whether to use package-specific tags instead of the
                 ForwardDiff default function-specific tags. For more information, see
@@ -1138,4 +1138,4 @@
               ```julia
               DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
               ```
-            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant

Keyword Arguments

References

source
diff --git a/dev/misc/index.html b/dev/misc/index.html index 822ccc5114..c6f22fda17 100644 --- a/dev/misc/index.html +++ b/dev/misc/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
GitHub
Missing docstring.

Missing docstring for 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 SplitEuler. Check Documenter's build log for details.

Missing docstring.

Missing docstring for CompositeAlgorithm. Check Documenter's build log for details.

diff --git a/dev/semiimplicit/ExponentialRK/index.html b/dev/semiimplicit/ExponentialRK/index.html index f398570387..5a8b294fce 100644 --- a/dev/semiimplicit/ExponentialRK/index.html +++ b/dev/semiimplicit/ExponentialRK/index.html @@ -17,30 +17,30 @@ prob = ODEProblem(lorenz!, u0, tspan) sol = solve(prob, EPIRK5s3())

Full list of solvers

OrdinaryDiffEqExponentialRK.LawsonEuler — Type
LawsonEuler(; krylov = false,
               m = 30,
-              iop = 0)

Semilinear ODE solver First order exponential Euler scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.NorsettEuler — Type
NorsettEuler(; krylov = false,
+              iop = 0)

Semilinear ODE solver First order exponential Euler scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.NorsettEuler — Type
NorsettEuler(; krylov = false,
                m = 30,
-               iop = 0)

Semilinear ODE solver First order exponential-RK scheme. Alias: ETD1

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETD2 — Type

ETD2: Exponential Runge-Kutta Method Second order Exponential Time Differencing method (in development).

source
OrdinaryDiffEqExponentialRK.ETDRK2 — Type
ETDRK2(; krylov = false,
+               iop = 0)

Semilinear ODE solver First order exponential-RK scheme. Alias: ETD1

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETD2 — Type

ETD2: Exponential Runge-Kutta Method Second order Exponential Time Differencing method (in development).

source
OrdinaryDiffEqExponentialRK.ETDRK2 — Type
ETDRK2(; krylov = false,
          m = 30,
-         iop = 0)

Semilinear ODE solver 2nd order exponential-RK scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETDRK3 — Type
ETDRK3(; krylov = false,
+         iop = 0)

Semilinear ODE solver 2nd order exponential-RK scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETDRK3 — Type
ETDRK3(; krylov = false,
          m = 30,
-         iop = 0)

Semilinear ODE solver 3rd order exponential-RK scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETDRK4 — Type
ETDRK4(; krylov = false,
+         iop = 0)

Semilinear ODE solver 3rd order exponential-RK scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETDRK4 — Type
ETDRK4(; krylov = false,
          m = 30,
-         iop = 0)

Semilinear ODE solver 4th order exponential-RK scheme

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.HochOst4 — Type
HochOst4(; krylov = false,
+         iop = 0)

Semilinear ODE solver 4th order exponential-RK scheme

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.HochOst4 — Type
HochOst4(; krylov = false,
            m = 30,
-           iop = 0)

Semilinear ODE solver 4th order exponential-RK scheme with stiff order 4.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source

Adaptive Exponential Rosenbrock Methods

OrdinaryDiffEqExponentialRK.Exprb32 — Type
Exprb32(; m = 30,
-          iop = 0)

Semilinear ODE solver 3rd order adaptive Exponential-Rosenbrock scheme.

Keyword Arguments

  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, M., & Ostermann, A. (2010). Exponential integrators. Acta Numerica, 19, 209-286. (https://doi.org/10.1017/S0962492910000048)

source
OrdinaryDiffEqExponentialRK.Exprb43 — Type
Exprb43(; m = 30,
-          iop = 0)

Semilinear ODE solver 4th order adaptive Exponential-Rosenbrock scheme.

Keyword Arguments

  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, M., & Ostermann, A. (2010). Exponential integrators. Acta Numerica, 19, 209-286. (https://doi.org/10.1017/S0962492910000048)

source

Exponential Propagation Iterative Runge-Kutta Methods (EPIRK)

OrdinaryDiffEqExponentialRK.Exp4 — Type
Exp4(; adaptive_krylov = true,
+           iop = 0)

Semilinear ODE solver 4th order exponential-RK scheme with stiff order 4.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source

Adaptive Exponential Rosenbrock Methods

OrdinaryDiffEqExponentialRK.Exprb32 — Type
Exprb32(; m = 30,
+          iop = 0)

Semilinear ODE solver 3rd order adaptive Exponential-Rosenbrock scheme.

Keyword Arguments

  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, M., & Ostermann, A. (2010). Exponential integrators. Acta Numerica, 19, 209-286. (https://doi.org/10.1017/S0962492910000048)

source
OrdinaryDiffEqExponentialRK.Exprb43 — Type
Exprb43(; m = 30,
+          iop = 0)

Semilinear ODE solver 4th order adaptive Exponential-Rosenbrock scheme.

Keyword Arguments

  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, M., & Ostermann, A. (2010). Exponential integrators. Acta Numerica, 19, 209-286. (https://doi.org/10.1017/S0962492910000048)

source

Exponential Propagation Iterative Runge-Kutta Methods (EPIRK)

OrdinaryDiffEqExponentialRK.Exp4 — Type
Exp4(; adaptive_krylov = true,
        m = 30,
-       iop = 0)

Semilinear ODE solver 4th order EPIRK scheme.

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, M., Lubich, C., & Selhofer, H. (1998). Exponential integrators for large systems of differential equations. SIAM Journal on Scientific Computing, 19(5), 1552-1574. (https://doi.org/10.1137/S1064827595295337)

source
OrdinaryDiffEqExponentialRK.EPIRK4s3A — Type
EPIRK4s3A(; adaptive_krylov = true,
+       iop = 0)

Semilinear ODE solver 4th order EPIRK scheme.

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, M., Lubich, C., & Selhofer, H. (1998). Exponential integrators for large systems of differential equations. SIAM Journal on Scientific Computing, 19(5), 1552-1574. (https://doi.org/10.1137/S1064827595295337)

source
OrdinaryDiffEqExponentialRK.EPIRK4s3A — Type
EPIRK4s3A(; adaptive_krylov = true,
             m = 30,
-            iop = 0)

Semilinear ODE solver 4th order EPIRK scheme with stiff order 4.

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Rainwater, G., & Tokman, M. (2016). A new approach to constructing efficient stiffly accurate EPIRK methods. Journal of Computational Physics, 323, 283-309. (https://doi.org/10.1016/j.jcp.2016.07.026)

source
OrdinaryDiffEqExponentialRK.EPIRK4s3B — Type
EPIRK4s3B(; adaptive_krylov = true,
+            iop = 0)

Semilinear ODE solver 4th order EPIRK scheme with stiff order 4.

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Rainwater, G., & Tokman, M. (2016). A new approach to constructing efficient stiffly accurate EPIRK methods. Journal of Computational Physics, 323, 283-309. (https://doi.org/10.1016/j.jcp.2016.07.026)

source
OrdinaryDiffEqExponentialRK.EPIRK4s3B — Type
EPIRK4s3B(; adaptive_krylov = true,
             m = 30,
-            iop = 0)

Semilinear ODE solver 4th order EPIRK scheme with stiff order 4.

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Rainwater, G., & Tokman, M. (2016). A new approach to constructing efficient stiffly accurate EPIRK methods. Journal of Computational Physics, 323, 283-309. (https://doi.org/10.1016/j.jcp.2016.07.026)

source
OrdinaryDiffEqExponentialRK.EPIRK5s3 — Type
EPIRK5s3(; adaptive_krylov = true,
+            iop = 0)

Semilinear ODE solver 4th order EPIRK scheme with stiff order 4.

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Rainwater, G., & Tokman, M. (2016). A new approach to constructing efficient stiffly accurate EPIRK methods. Journal of Computational Physics, 323, 283-309. (https://doi.org/10.1016/j.jcp.2016.07.026)

source
OrdinaryDiffEqExponentialRK.EPIRK5s3 — Type
EPIRK5s3(; adaptive_krylov = true,
            m = 30,
-           iop = 0)

Semilinear ODE solver 5th order “horizontal” EPIRK scheme with stiff order 5. Broken.

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Rainwater, G., & Tokman, M. (2016). A new approach to constructing efficient stiffly accurate EPIRK methods. Journal of Computational Physics, 323, 283-309. (https://doi.org/10.1016/j.jcp.2016.07.026)

source
OrdinaryDiffEqExponentialRK.EXPRB53s3 — Type
EXPRB53s3(; adaptive_krylov = true,
+           iop = 0)

Semilinear ODE solver 5th order “horizontal” EPIRK scheme with stiff order 5. Broken.

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Rainwater, G., & Tokman, M. (2016). A new approach to constructing efficient stiffly accurate EPIRK methods. Journal of Computational Physics, 323, 283-309. (https://doi.org/10.1016/j.jcp.2016.07.026)

source
OrdinaryDiffEqExponentialRK.EXPRB53s3 — Type
EXPRB53s3(; adaptive_krylov = true,
             m = 30,
-            iop = 0)

Semilinear ODE solver 5th order EPIRK scheme with stiff order 5.

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Rainwater, G., & Tokman, M. (2016). A new approach to constructing efficient stiffly accurate EPIRK methods. Journal of Computational Physics, 323, 283-309. (https://doi.org/10.1016/j.jcp.2016.07.026)

source
OrdinaryDiffEqExponentialRK.EPIRK5P1 — Type
EPIRK5P1(; adaptive_krylov = true,
+            iop = 0)

Semilinear ODE solver 5th order EPIRK scheme with stiff order 5.

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Rainwater, G., & Tokman, M. (2016). A new approach to constructing efficient stiffly accurate EPIRK methods. Journal of Computational Physics, 323, 283-309. (https://doi.org/10.1016/j.jcp.2016.07.026)

source
OrdinaryDiffEqExponentialRK.EPIRK5P1 — Type
EPIRK5P1(; adaptive_krylov = true,
            m = 30,
-           iop = 0)

Semilinear ODE solver 5th order EPIRK scheme

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Tokman, M., Loffeld, J., & Tranquilli, P. (2012). New Adaptive Exponential Propagation Iterative Methods of Runge–Kutta Type. SIAM Journal on Scientific Computing, 34(5), A2650-A2669. (https://doi.org/10.1137/110849961)

source
OrdinaryDiffEqExponentialRK.EPIRK5P2 — Type
EPIRK5P2(; adaptive_krylov = true,
+           iop = 0)

Semilinear ODE solver 5th order EPIRK scheme

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Tokman, M., Loffeld, J., & Tranquilli, P. (2012). New Adaptive Exponential Propagation Iterative Methods of Runge–Kutta Type. SIAM Journal on Scientific Computing, 34(5), A2650-A2669. (https://doi.org/10.1137/110849961)

source
OrdinaryDiffEqExponentialRK.EPIRK5P2 — Type
EPIRK5P2(; adaptive_krylov = true,
            m = 30,
-           iop = 0)

Semilinear ODE solver 5th order EPIRK scheme

Keyword Arguments

  • adaptive_krylov: Determines if the adaptive Krylov algorithm with timestepping of Neisen & Wright is used.
  • m: Controls the size of Krylov subspace. - iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Tokman, M., Loffeld, J., & Tranquilli, P. (2012). New Adaptive Exponential Propagation Iterative Methods of Runge–Kutta Type. SIAM Journal on Scientific Computing, 34(5), A2650-A2669. (https://doi.org/10.1137/110849961)

source
+ iop = 0)

Semilinear ODE solver 5th order EPIRK scheme

Keyword Arguments

References

Tokman, M., Loffeld, J., & Tranquilli, P. (2012). New Adaptive Exponential Propagation Iterative Methods of Runge–Kutta Type. SIAM Journal on Scientific Computing, 34(5), A2650-A2669. (https://doi.org/10.1137/110849961)

source
diff --git a/dev/semiimplicit/Rosenbrock/index.html b/dev/semiimplicit/Rosenbrock/index.html index bc2d519446..f7217589b7 100644 --- a/dev/semiimplicit/Rosenbrock/index.html +++ b/dev/semiimplicit/Rosenbrock/index.html @@ -21,14 +21,14 @@ diff_type = Val{:central}, linsolve = nothing, precs = DEFAULT_PRECS, - step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

References

Scientific Computing, 18 (1), pp. 1-22.

source
OrdinaryDiffEqRosenbrock.Rosenbrock32 — Type
Rosenbrock32(; chunk_size = Val{0}(),
+               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rosenbrock23(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rosenbrock32 — Type
Rosenbrock32(; chunk_size = Val{0}(),
                standardtag = Val{true}(),
                autodiff = Val{true}(),
                concrete_jac = nothing,
                diff_type = Val{:central},
                linsolve = nothing,
                precs = DEFAULT_PRECS,
-               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rosenbrock32(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.ROS3P — Type
ROS3P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rosenbrock32(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.ROS3P — Type
ROS3P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
             and thus uses the internal ForwardDiff.jl algorithm for the choice.
         - `standardtag`: Specifies whether to use package-specific tags instead of the
             ForwardDiff default function-specific tags. For more information, see
@@ -82,7 +82,7 @@
           ```julia
           DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
           ```
-        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. 3rd order A-stable and stiffly stable Rosenbrock method. Keeps high accuracy on discretizations of nonlinear parabolic PDEs.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas3 — Type
Rodas3(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. 3rd order A-stable and stiffly stable Rosenbrock method. Keeps high accuracy on discretizations of nonlinear parabolic PDEs.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas3 — Type
Rodas3(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -136,14 +136,14 @@
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
            ```
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. 3rd order A-stable and stiffly stable Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas23W — Type
Rodas23W(; chunk_size = Val{0}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. 3rd order A-stable and stiffly stable Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas23W — Type
Rodas23W(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
            precs = DEFAULT_PRECS,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas23W(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas3P — Type
Rodas3P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas23W(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas3P — Type
Rodas3P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
               and thus uses the internal ForwardDiff.jl algorithm for the choice.
           - `standardtag`: Specifies whether to use package-specific tags instead of the
               ForwardDiff default function-specific tags. For more information, see
@@ -197,7 +197,7 @@
             ```julia
             DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
             ```
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4 — Type
Rodas4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4 — Type
Rodas4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -251,7 +251,7 @@
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
            ```
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order L-stable Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas42 — Type
Rodas42(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order L-stable Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas42 — Type
Rodas42(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
               and thus uses the internal ForwardDiff.jl algorithm for the choice.
           - `standardtag`: Specifies whether to use package-specific tags instead of the
               ForwardDiff default function-specific tags. For more information, see
@@ -305,7 +305,7 @@
             ```julia
             DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
             ```
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4P — Type
Rodas4P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4P — Type
Rodas4P(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
               and thus uses the internal ForwardDiff.jl algorithm for the choice.
           - `standardtag`: Specifies whether to use package-specific tags instead of the
               ForwardDiff default function-specific tags. For more information, see
@@ -359,14 +359,14 @@
             ```julia
             DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
             ```
-          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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4P2 — Type
Rodas4P2(; chunk_size = Val{0}(),
+          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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas4P2 — Type
Rodas4P2(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
            precs = DEFAULT_PRECS,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas4P2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas5 — Type
Rodas5(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas4P2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas5 — Type
Rodas5(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -420,34 +420,34 @@
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
            ```
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 5th order A-stable stiffly stable Rosenbrock method with a stiff-aware 4th order interpolant.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas5P — Type
Rodas5P(; chunk_size = Val{0}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 5th order A-stable stiffly stable Rosenbrock method with a stiff-aware 4th order interpolant.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Rodas5P — Type
Rodas5P(; chunk_size = Val{0}(),
           standardtag = Val{true}(),
           autodiff = Val{true}(),
           concrete_jac = nothing,
           diff_type = Val{:central},
           linsolve = nothing,
           precs = DEFAULT_PRECS,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5P(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas5Pe — Type
Rodas5Pe(; chunk_size = Val{0}(),
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5P(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.Rodas5Pe — Type
Rodas5Pe(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
            precs = DEFAULT_PRECS,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5Pe(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Rosenbrock methods within OrdinaryDiffEq.jl - Overview, recent developments and applications - Preprint 2024 https://github.com/hbrs-cse/RosenbrockMethods/blob/main/paper/JuliaPaper.pdf
source
OrdinaryDiffEqRosenbrock.Rodas5Pr — Type
Rodas5Pr(; chunk_size = Val{0}(),
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5Pe(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Rosenbrock methods within OrdinaryDiffEq.jl - Overview, recent developments and applications - Preprint 2024 https://github.com/hbrs-cse/RosenbrockMethods/blob/main/paper/JuliaPaper.pdf
source
OrdinaryDiffEqRosenbrock.Rodas5Pr — Type
Rodas5Pr(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
            precs = DEFAULT_PRECS,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5Pr(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Rosenbrock methods within OrdinaryDiffEq.jl - Overview, recent developments and applications - Preprint 2024 https://github.com/hbrs-cse/RosenbrockMethods/blob/main/paper/JuliaPaper.pdf
source
OrdinaryDiffEqRosenbrock.RosenbrockW6S4OS — Type
RosenbrockW6S4OS(; chunk_size = Val{0}(),
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Rodas5Pr(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Rosenbrock methods within OrdinaryDiffEq.jl - Overview, recent developments and applications - Preprint 2024 https://github.com/hbrs-cse/RosenbrockMethods/blob/main/paper/JuliaPaper.pdf
source
OrdinaryDiffEqRosenbrock.RosenbrockW6S4OS — Type
RosenbrockW6S4OS(; chunk_size = Val{0}(),
                    standardtag = Val{true}(),
                    autodiff = Val{true}(),
                    concrete_jac = nothing,
                    diff_type = Val{:central},
                    linsolve = nothing,
-                   precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order L-stable Rosenbrock-W method (fixed step only).

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify RosenbrockW6S4OS(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

https://doi.org/10.1016/j.cam.2009.09.017

source
OrdinaryDiffEqRosenbrock.ROS2 — Type
ROS2(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+                   precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order L-stable Rosenbrock-W method (fixed step only).

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify RosenbrockW6S4OS(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

https://doi.org/10.1016/j.cam.2009.09.017

source
OrdinaryDiffEqRosenbrock.ROS2 — Type
ROS2(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
            and thus uses the internal ForwardDiff.jl algorithm for the choice.
        - `standardtag`: Specifies whether to use package-specific tags instead of the
            ForwardDiff default function-specific tags. For more information, see
@@ -500,7 +500,7 @@
          is defined as:
          ```julia
          DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-         ```)

Rosenbrock-Wanner Method. A 2nd order L-stable Rosenbrock method with 2 internal stages.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS2PR — Type
ROS2PR(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+         ```)

Rosenbrock-Wanner Method. A 2nd order L-stable Rosenbrock method with 2 internal stages.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS2PR — Type
ROS2PR(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -553,13 +553,13 @@
            is defined as:
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-           ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS2S — Type
ROS2S(; chunk_size = Val{0}(),
+           ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS2S — Type
ROS2S(; chunk_size = Val{0}(),
         standardtag = Val{true}(),
         autodiff = Val{true}(),
         concrete_jac = nothing,
         diff_type = Val{:central},
         linsolve = nothing,
-        precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS2S(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

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
OrdinaryDiffEqRosenbrock.ROS3 — Type
ROS3(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+        precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS2S(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

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
OrdinaryDiffEqRosenbrock.ROS3 — Type
ROS3(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
            and thus uses the internal ForwardDiff.jl algorithm for the choice.
        - `standardtag`: Specifies whether to use package-specific tags instead of the
            ForwardDiff default function-specific tags. For more information, see
@@ -612,7 +612,7 @@
          is defined as:
          ```julia
          DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-         ```)

Rosenbrock-Wanner Method. 3rd order L-stable Rosenbrock method with 3 internal stages with an embedded strongly A-stable 2nd order method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS3PR — Type
ROS3PR(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+         ```)

Rosenbrock-Wanner Method. 3rd order L-stable Rosenbrock method with 3 internal stages with an embedded strongly A-stable 2nd order method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS3PR — Type
ROS3PR(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -665,7 +665,7 @@
            is defined as:
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-           ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Scholz4_7 — Type
Scholz4_7(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+           ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Scholz4_7 — Type
Scholz4_7(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
                 and thus uses the internal ForwardDiff.jl algorithm for the choice.
             - `standardtag`: Specifies whether to use package-specific tags instead of the
                 ForwardDiff default function-specific tags. For more information, see
@@ -718,37 +718,37 @@
               is defined as:
               ```julia
               DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-              ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS34PW1a — Type
ROS34PW1a(; chunk_size = Val{0}(),
+              ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS34PW1a — Type
ROS34PW1a(; chunk_size = Val{0}(),
             standardtag = Val{true}(),
             autodiff = Val{true}(),
             concrete_jac = nothing,
             diff_type = Val{:central},
             linsolve = nothing,
-            precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW1a(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW1b — Type
ROS34PW1b(; chunk_size = Val{0}(),
+            precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW1a(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW1b — Type
ROS34PW1b(; chunk_size = Val{0}(),
             standardtag = Val{true}(),
             autodiff = Val{true}(),
             concrete_jac = nothing,
             diff_type = Val{:central},
             linsolve = nothing,
-            precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW1b(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW2 — Type
ROS34PW2(; chunk_size = Val{0}(),
+            precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW1b(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW2 — Type
ROS34PW2(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
-           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order stiffy accurate Rosenbrock-W method for PDAEs.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW3 — Type
ROS34PW3(; chunk_size = Val{0}(),
+           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order stiffy accurate Rosenbrock-W method for PDAEs.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW2(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PW3 — Type
ROS34PW3(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
-           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order strongly A-stable (Rinf~0.63) Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PRw — Type
ROS34PRw(; chunk_size = Val{0}(),
+           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order strongly A-stable (Rinf~0.63) Rosenbrock-W method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PW3(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

@article{rang2005new, title={New Rosenbrock W-methods of order 3 for partial differential algebraic equations of index 1}, author={Rang, Joachim and Angermann, L}, journal={BIT Numerical Mathematics}, volume={45}, pages={761–787}, year={2005}, publisher={Springer}}

source
OrdinaryDiffEqRosenbrock.ROS34PRw — Type
ROS34PRw(; chunk_size = Val{0}(),
            standardtag = Val{true}(),
            autodiff = Val{true}(),
            concrete_jac = nothing,
            diff_type = Val{:central},
            linsolve = nothing,
-           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PRw(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

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
OrdinaryDiffEqRosenbrock.ROS3PRL — Type
ROS3PRL(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+           precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROS34PRw(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

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
OrdinaryDiffEqRosenbrock.ROS3PRL — Type
ROS3PRL(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
               and thus uses the internal ForwardDiff.jl algorithm for the choice.
           - `standardtag`: Specifies whether to use package-specific tags instead of the
               ForwardDiff default function-specific tags. For more information, see
@@ -801,7 +801,7 @@
             is defined as:
             ```julia
             DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-            ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS3PRL2 — Type
ROS3PRL2(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+            ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROS3PRL2 — Type
ROS3PRL2(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
                and thus uses the internal ForwardDiff.jl algorithm for the choice.
            - `standardtag`: Specifies whether to use package-specific tags instead of the
                ForwardDiff default function-specific tags. For more information, see
@@ -854,13 +854,13 @@
              is defined as:
              ```julia
              DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-             ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROK4a — Type
ROK4a(; chunk_size = Val{0}(),
+             ```)

Rosenbrock-Wanner 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

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.ROK4a — Type
ROK4a(; chunk_size = Val{0}(),
         standardtag = Val{true}(),
         autodiff = Val{true}(),
         concrete_jac = nothing,
         diff_type = Val{:central},
         linsolve = nothing,
-        precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROK4a(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

  • Tranquilli, Paul and Sandu, Adrian (2014): Rosenbrock–Krylov Methods for Large Systems of Differential Equations https://doi.org/10.1137/130923336
source
OrdinaryDiffEqRosenbrock.RosShamp4 — Type
RosShamp4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+        precs = DEFAULT_PRECS)

Rosenbrock-Wanner-W(olfbrandt) 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

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify ROK4a(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing

References

  • Tranquilli, Paul and Sandu, Adrian (2014): Rosenbrock–Krylov Methods for Large Systems of Differential Equations https://doi.org/10.1137/130923336
source
OrdinaryDiffEqRosenbrock.RosShamp4 — Type
RosShamp4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
                 and thus uses the internal ForwardDiff.jl algorithm for the choice.
             - `standardtag`: Specifies whether to use package-specific tags instead of the
                 ForwardDiff default function-specific tags. For more information, see
@@ -913,7 +913,7 @@
               is defined as:
               ```julia
               DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
-              ```)

Rosenbrock-Wanner Method. An A-stable 4th order Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Veldd4 — Type
Veldd4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+              ```)

Rosenbrock-Wanner Method. An A-stable 4th order Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Veldd4 — Type
Veldd4(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
              and thus uses the internal ForwardDiff.jl algorithm for the choice.
          - `standardtag`: Specifies whether to use package-specific tags instead of the
              ForwardDiff default function-specific tags. For more information, see
@@ -967,14 +967,14 @@
            ```julia
            DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
            ```
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order D-stable Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Velds4 — Type
Velds4(; chunk_size = Val{0}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order D-stable Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Velds4 — Type
Velds4(; chunk_size = Val{0}(),
          standardtag = Val{true}(),
          autodiff = Val{true}(),
          concrete_jac = nothing,
          diff_type = Val{:central},
          linsolve = nothing,
          precs = DEFAULT_PRECS,
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order A-stable Rosenbrock method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Velds4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.GRK4T — Type
GRK4T(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner-W(olfbrandt) Method. A 4th order A-stable Rosenbrock method.

Keyword Arguments

  • chunk_size: The chunk size used with ForwardDiff.jl. Defaults to Val{0}() and thus uses the internal ForwardDiff.jl algorithm for the choice.
  • standardtag: Specifies whether to use package-specific tags instead of the ForwardDiff default function-specific tags. For more information, see this blog post. Defaults to Val{true}().
  • autodiff: Specifies whether to use automatic differentiation via ForwardDiff.jl or finite differencing via FiniteDiff.jl. Defaults to Val{true}() for automatic differentiation.
  • concrete_jac: Specifies whether a Jacobian should be constructed. Defaults to nothing, which means it will be chosen true/false depending on circumstances of the solver, such as whether a Krylov subspace method is used for linsolve.
  • diff_type: The type of differentiation used in FiniteDiff.jl if autodiff=false. Defaults to Val{:forward}, with alternatives of Val{:central} and Val{:complex}.
  • linsolve: Any LinearSolve.jl compatible linear solver. For example, to use KLU.jl, specify Velds4(linsolve = KLUFactorization()). When nothing is passed, uses DefaultLinearSolver.
  • precs: Any LinearSolve.jl-compatible preconditioner can be used as a left or right preconditioner. Preconditioners are specified by the Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata) function where the arguments are defined as:
    • W: the current Jacobian of the nonlinear system. Specified as either $I - \gamma J$ or $I/\gamma - J$ depending on the algorithm. This will commonly be a WOperator type defined by OrdinaryDiffEq.jl. It is a lazy representation of the operator. Users can construct the W-matrix on demand by calling convert(AbstractMatrix,W) to receive an AbstractMatrix matching the jac_prototype.
    • du: the current ODE derivative
    • u: the current ODE state
    • p: the ODE parameters
    • t: the current ODE time
    • newW: a Bool which specifies whether the W matrix has been updated since the last call to precs. It is recommended that this is checked to only update the preconditioner when newW == true.
    • Plprev: the previous Pl.
    • Prprev: the previous Pr.
    • solverdata: Optional extra data the solvers can give to the precs function. Solver-dependent and subject to change.
    The return is a tuple (Pl,Pr) of the LinearSolve.jl-compatible preconditioners. To specify one-sided preconditioning, simply return nothing for the preconditioner which is not used. Additionally, precs must supply the dispatch:
    Pl, Pr = precs(W, du, u, p, t, ::Nothing, ::Nothing, ::Nothing, solverdata)
    which is used in the solver setup phase to construct the integrator type with the preconditioners (Pl,Pr). The default is precs=DEFAULT_PRECS where the default preconditioner function is defined as:
    DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
  • 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
OrdinaryDiffEqRosenbrock.GRK4T — Type
GRK4T(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
             and thus uses the internal ForwardDiff.jl algorithm for the choice.
         - `standardtag`: Specifies whether to use package-specific tags instead of the
             ForwardDiff default function-specific tags. For more information, see
@@ -1028,7 +1028,7 @@
           ```julia
           DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
           ```
-        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An efficient 4th order Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.GRK4A — Type
GRK4A(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An efficient 4th order Rosenbrock method.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.GRK4A — Type
GRK4A(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
             and thus uses the internal ForwardDiff.jl algorithm for the choice.
         - `standardtag`: Specifies whether to use package-specific tags instead of the
             ForwardDiff default function-specific tags. For more information, see
@@ -1082,7 +1082,7 @@
           ```julia
           DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
           ```
-        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An A-stable 4th order Rosenbrock method. Essentially "anti-L-stable" but efficient.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Ros4LStab — Type
Ros4LStab(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An A-stable 4th order Rosenbrock method. Essentially "anti-L-stable" but efficient.

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
OrdinaryDiffEqRosenbrock.Ros4LStab — Type
Ros4LStab(; - `chunk_size`: The chunk size used with ForwardDiff.jl. Defaults to `Val{0}()`
                 and thus uses the internal ForwardDiff.jl algorithm for the choice.
             - `standardtag`: Specifies whether to use package-specific tags instead of the
                 ForwardDiff default function-specific tags. For more information, see
@@ -1136,4 +1136,4 @@
               ```julia
               DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing
               ```
-            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant

Keyword Arguments

  • chunk_size: TBD
  • standardtag: TBD
  • 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)
  • diff_type: TBD
  • 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
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant

Keyword Arguments

References

source
diff --git a/dev/semiimplicit/StabilizedRK/index.html b/dev/semiimplicit/StabilizedRK/index.html index dc83c8c60d..760adb8929 100644 --- a/dev/semiimplicit/StabilizedRK/index.html +++ b/dev/semiimplicit/StabilizedRK/index.html @@ -16,7 +16,7 @@ prob = ODEProblem(lorenz!, u0, tspan) sol = solve(prob, ROCK4())

Full list of solvers

OrdinaryDiffEqStabilizedRK.ROCK2 — Type
ROCK2(; min_stages = 0,
         max_stages = 200,
-        eigen_est = nothing)

Stabilized Explicit Method. Second order method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

Keyword Arguments

  • min_stages: The minimum degree of the Chebyshev polynomial.
  • max_stages: The maximumdegree of the Chebyshev polynomial.
  • eigen_est: function of the form (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.

References

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

source
OrdinaryDiffEqStabilizedRK.ROCK4 — Type
ROCK4(; min_stages = 0,
+        eigen_est = nothing)

Stabilized Explicit Method. Second order method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

Keyword Arguments

  • min_stages: The minimum degree of the Chebyshev polynomial.
  • max_stages: The maximumdegree of the Chebyshev polynomial.
  • eigen_est: function of the form (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.

References

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

source
OrdinaryDiffEqStabilizedRK.ROCK4 — Type
ROCK4(; min_stages = 0,
         max_stages = 152,
-        eigen_est = nothing)

Stabilized Explicit Method. Fourth order method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

Keyword Arguments

  • min_stages: The minimum degree of the Chebyshev polynomial.
  • max_stages: The maximumdegree of the Chebyshev polynomial.
  • eigen_est: function of the form (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.

References

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

source
OrdinaryDiffEqStabilizedRK.RKC — Type
RKC(; eigen_est = nothing)

Stabilized Explicit Method. Second order method. Exhibits high stability for real eigenvalues.

Keyword Arguments

  • eigen_est: function of the form (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.

References

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

source
OrdinaryDiffEqStabilizedRK.SERK2 — Type
SERK2(; controller = :PI
-        eigen_est = nothing)

Stabilized Explicit Method. Second order method.

Keyword Arguments

  • controller: TBD
  • eigen_est: function of the form (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.

References

@article{kleefeld2013serk2v2, title={SERK2v2: A new second-order stabilized explicit Runge-Kutta method for stiff problems}, author={Kleefeld, B and Martin-Vaquero, J}, journal={Numerical Methods for Partial Differential Equations}, volume={29}, number={1}, pages={170–185}, year={2013}, publisher={Wiley Online Library}}

source
OrdinaryDiffEqStabilizedRK.ESERK4 — Type
ESERK4(; eigen_est = nothing)

Stabilized Explicit Method. Fourth order method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

Keyword Arguments

  • eigen_est: function of the form (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.

References

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.

source
OrdinaryDiffEqStabilizedRK.ESERK5 — Type
ESERK5(; eigen_est = nothing)

Stabilized Explicit Method. Fifth order method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

Keyword Arguments

  • eigen_est: function of the form (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.

References

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.

source
+ eigen_est = nothing)

Stabilized Explicit Method. Fourth order method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

Keyword Arguments

References

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

source
OrdinaryDiffEqStabilizedRK.RKC — Type
RKC(; eigen_est = nothing)

Stabilized Explicit Method. Second order method. Exhibits high stability for real eigenvalues.

Keyword Arguments

  • eigen_est: function of the form (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.

References

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

source
OrdinaryDiffEqStabilizedRK.SERK2 — Type
SERK2(; controller = :PI
+        eigen_est = nothing)

Stabilized Explicit Method. Second order method.

Keyword Arguments

  • controller: TBD
  • eigen_est: function of the form (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.

References

@article{kleefeld2013serk2v2, title={SERK2v2: A new second-order stabilized explicit Runge-Kutta method for stiff problems}, author={Kleefeld, B and Martin-Vaquero, J}, journal={Numerical Methods for Partial Differential Equations}, volume={29}, number={1}, pages={170–185}, year={2013}, publisher={Wiley Online Library}}

source
OrdinaryDiffEqStabilizedRK.ESERK4 — Type
ESERK4(; eigen_est = nothing)

Stabilized Explicit Method. Fourth order method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

Keyword Arguments

  • eigen_est: function of the form (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.

References

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.

source
OrdinaryDiffEqStabilizedRK.ESERK5 — Type
ESERK5(; eigen_est = nothing)

Stabilized Explicit Method. Fifth order method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

Keyword Arguments

  • eigen_est: function of the form (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.

References

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.

source
diff --git a/dev/semilinear/ExponentialRK/index.html b/dev/semilinear/ExponentialRK/index.html index b7d3d63cae..1468931bd0 100644 --- a/dev/semilinear/ExponentialRK/index.html +++ b/dev/semilinear/ExponentialRK/index.html @@ -14,14 +14,14 @@ prob = SplitODEProblem(linnonlin_fun_iip, u0, tspan) sol = solve(prob, ETDRK4(), dt = 1 / 4)

Full list of solvers

OrdinaryDiffEqExponentialRK.LawsonEuler — Type
LawsonEuler(; krylov = false,
               m = 30,
-              iop = 0)

Semilinear ODE solver First order exponential Euler scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.NorsettEuler — Type
NorsettEuler(; krylov = false,
+              iop = 0)

Semilinear ODE solver First order exponential Euler scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.NorsettEuler — Type
NorsettEuler(; krylov = false,
                m = 30,
-               iop = 0)

Semilinear ODE solver First order exponential-RK scheme. Alias: ETD1

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETD2 — Type

ETD2: Exponential Runge-Kutta Method Second order Exponential Time Differencing method (in development).

source
OrdinaryDiffEqExponentialRK.ETDRK2 — Type
ETDRK2(; krylov = false,
+               iop = 0)

Semilinear ODE solver First order exponential-RK scheme. Alias: ETD1

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETD2 — Type

ETD2: Exponential Runge-Kutta Method Second order Exponential Time Differencing method (in development).

source
OrdinaryDiffEqExponentialRK.ETDRK2 — Type
ETDRK2(; krylov = false,
          m = 30,
-         iop = 0)

Semilinear ODE solver 2nd order exponential-RK scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETDRK3 — Type
ETDRK3(; krylov = false,
+         iop = 0)

Semilinear ODE solver 2nd order exponential-RK scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETDRK3 — Type
ETDRK3(; krylov = false,
          m = 30,
-         iop = 0)

Semilinear ODE solver 3rd order exponential-RK scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETDRK4 — Type
ETDRK4(; krylov = false,
+         iop = 0)

Semilinear ODE solver 3rd order exponential-RK scheme.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.ETDRK4 — Type
ETDRK4(; krylov = false,
          m = 30,
-         iop = 0)

Semilinear ODE solver 4th order exponential-RK scheme

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.HochOst4 — Type
HochOst4(; krylov = false,
+         iop = 0)

Semilinear ODE solver 4th order exponential-RK scheme

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
OrdinaryDiffEqExponentialRK.HochOst4 — Type
HochOst4(; krylov = false,
            m = 30,
-           iop = 0)

Semilinear ODE solver 4th order exponential-RK scheme with stiff order 4.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
+ iop = 0)

Semilinear ODE solver 4th order exponential-RK scheme with stiff order 4.

Keyword Arguments

References

Hochbruck, Marlis, and Alexander Ostermann. “Exponential Integrators.” Acta Numerica 19 (2010): 209–286. doi:10.1017/S0962492910000048.

source
diff --git a/dev/semilinear/Linear/index.html b/dev/semilinear/Linear/index.html index 61196d0343..b07ae9832f 100644 --- a/dev/semilinear/Linear/index.html +++ b/dev/semilinear/Linear/index.html @@ -18,34 +18,34 @@ prob = ODEProblem(A, u0, tspan) sol = solve(prob, LieRK4(), dt = 1 / 4)

Full list of solvers

Time and State-Independent Solvers

OrdinaryDiffEqLinear.LinearExponential — Type
LinearExponential(; krylov = :off,
                     m = 10,
-                    iop = 0)

Semilinear ODE solver Exact solution formula for linear, time-independent problems.

Keyword Arguments

  • krylov:
    • :off: cache the operator beforehand. Requires Matrix(A) method defined for the operator A.
    • :simple: uses simple Krylov approximations with fixed subspace size m.
    • :adaptive: uses adaptive Krylov approximations with internal timestepping.
  • m: Controls the size of Krylov subspace if krylov=:simple, and the initial subspace size if krylov=:adaptive.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@book{strogatz2018nonlinear, title={Nonlinear dynamics and chaos: with applications to physics, biology, chemistry, and engineering}, author={Strogatz, Steven H}, year={2018}, publisher={CRC press}}

source

Time-Dependent and State-Independent Solvers

OrdinaryDiffEqLinear.MagnusMidpoint — Type
MagnusMidpoint(; krylov = false,
+                    iop = 0)

Semilinear ODE solver Exact solution formula for linear, time-independent problems.

Keyword Arguments

  • krylov:
    • :off: cache the operator beforehand. Requires Matrix(A) method defined for the operator A.
    • :simple: uses simple Krylov approximations with fixed subspace size m.
    • :adaptive: uses adaptive Krylov approximations with internal timestepping.
  • m: Controls the size of Krylov subspace if krylov=:simple, and the initial subspace size if krylov=:adaptive.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@book{strogatz2018nonlinear, title={Nonlinear dynamics and chaos: with applications to physics, biology, chemistry, and engineering}, author={Strogatz, Steven H}, year={2018}, publisher={CRC press}}

source

Time-Dependent and State-Independent Solvers

OrdinaryDiffEqLinear.MagnusMidpoint — Type
MagnusMidpoint(; krylov = false,
                  m = 30,
-                 iop = 0)

Semilinear ODE solver Second order Magnus Midpoint method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

https://joshuagoings.com/2017/06/15/magnus/

source
OrdinaryDiffEqLinear.MagnusLeapfrog — Type
MagnusLeapfrog(; krylov = false,
+                 iop = 0)

Semilinear ODE solver Second order Magnus Midpoint method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

https://joshuagoings.com/2017/06/15/magnus/

source
OrdinaryDiffEqLinear.MagnusLeapfrog — Type
MagnusLeapfrog(; krylov = false,
                  m = 30,
-                 iop = 0)

Semilinear ODE solver Second order Magnus Leapfrog method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

https://joshuagoings.com/2017/06/15/magnus/

source
OrdinaryDiffEqLinear.MagnusGauss4 — Type
MagnusGauss4(; krylov = false,
+                 iop = 0)

Semilinear ODE solver Second order Magnus Leapfrog method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

https://joshuagoings.com/2017/06/15/magnus/

source
OrdinaryDiffEqLinear.MagnusGauss4 — Type
MagnusGauss4(; krylov = false,
                m = 30,
-               iop = 0)

Semilinear ODE solver Fourth order Magnus method approximated using a two stage Gauss quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{hairer2011solving, title={Solving differential equations on manifolds}, author={Hairer, Ernst}, journal={Lecture notes}, year={2011} }

source
OrdinaryDiffEqLinear.MagnusNC6 — Type
MagnusNC6(; krylov = false,
+               iop = 0)

Semilinear ODE solver Fourth order Magnus method approximated using a two stage Gauss quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{hairer2011solving, title={Solving differential equations on manifolds}, author={Hairer, Ernst}, journal={Lecture notes}, year={2011} }

source
OrdinaryDiffEqLinear.MagnusNC6 — Type
MagnusNC6(; krylov = false,
             m = 30,
-            iop = 0)

Semilinear ODE solver Sixth order Magnus method approximated using Newton-Cotes quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{blanes2000improved, title={Improved high order integrators based on the Magnus expansion}, author={Blanes, Sergio and Casas, Fernando and Ros, Javier}, journal={BIT Numerical Mathematics}, volume={40}, number={3}, pages={434–450}, year={2000}, publisher={Springer} }

source
OrdinaryDiffEqLinear.MagnusGL6 — Type
MagnusGL6(; krylov = false,
+            iop = 0)

Semilinear ODE solver Sixth order Magnus method approximated using Newton-Cotes quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{blanes2000improved, title={Improved high order integrators based on the Magnus expansion}, author={Blanes, Sergio and Casas, Fernando and Ros, Javier}, journal={BIT Numerical Mathematics}, volume={40}, number={3}, pages={434–450}, year={2000}, publisher={Springer} }

source
OrdinaryDiffEqLinear.MagnusGL6 — Type
MagnusGL6(; krylov = false,
             m = 30,
-            iop = 0)

Semilinear ODE solver Sixth order Magnus method approximated using Gauss-Legendre quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{blanes2000improved, title={Improved high order integrators based on the Magnus expansion}, author={Blanes, Sergio and Casas, Fernando and Ros, Javier}, journal={BIT Numerical Mathematics}, volume={40}, number={3}, pages={434–450}, year={2000}, publisher={Springer} }

source
OrdinaryDiffEqLinear.MagnusGL8 — Type
MagnusGL8(; krylov = false,
+            iop = 0)

Semilinear ODE solver Sixth order Magnus method approximated using Gauss-Legendre quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{blanes2000improved, title={Improved high order integrators based on the Magnus expansion}, author={Blanes, Sergio and Casas, Fernando and Ros, Javier}, journal={BIT Numerical Mathematics}, volume={40}, number={3}, pages={434–450}, year={2000}, publisher={Springer} }

source
OrdinaryDiffEqLinear.MagnusGL8 — Type
MagnusGL8(; krylov = false,
             m = 30,
-            iop = 0)

Semilinear ODE solver Eighth order Magnus method approximated using Newton-Cotes quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{blanes2000improved, title={Improved high order integrators based on the Magnus expansion}, author={Blanes, Sergio and Casas, Fernando and Ros, Javier}, journal={BIT Numerical Mathematics}, volume={40}, number={3}, pages={434–450}, year={2000}, publisher={Springer} }

source
OrdinaryDiffEqLinear.MagnusNC8 — Type
MagnusNC8(; krylov = false,
+            iop = 0)

Semilinear ODE solver Eighth order Magnus method approximated using Newton-Cotes quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{blanes2000improved, title={Improved high order integrators based on the Magnus expansion}, author={Blanes, Sergio and Casas, Fernando and Ros, Javier}, journal={BIT Numerical Mathematics}, volume={40}, number={3}, pages={434–450}, year={2000}, publisher={Springer} }

source
OrdinaryDiffEqLinear.MagnusNC8 — Type
MagnusNC8(; krylov = false,
             m = 30,
-            iop = 0)

Semilinear ODE solver Eighth order Magnus method approximated using Gauss-Legendre quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{blanes2000improved, title={Improved high order integrators based on the Magnus expansion}, author={Blanes, Sergio and Casas, Fernando and Ros, Javier}, journal={BIT Numerical Mathematics}, volume={40}, number={3}, pages={434–450}, year={2000}, publisher={Springer} }

source
OrdinaryDiffEqLinear.MagnusGL4 — Type
MagnusGL4(; krylov = false,
+            iop = 0)

Semilinear ODE solver Eighth order Magnus method approximated using Gauss-Legendre quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{blanes2000improved, title={Improved high order integrators based on the Magnus expansion}, author={Blanes, Sergio and Casas, Fernando and Ros, Javier}, journal={BIT Numerical Mathematics}, volume={40}, number={3}, pages={434–450}, year={2000}, publisher={Springer} }

source
OrdinaryDiffEqLinear.MagnusGL4 — Type
MagnusGL4(; krylov = false,
             m = 30,
-            iop = 0)

Semilinear ODE solver Fourth order Magnus method approximated using Gauss-Legendre quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{blanes2009magnus, title={The Magnus expansion and some of its applications}, author={Blanes, Sergio and Casas, Fernando and Oteo, Jose-Angel and Ros, Jos{'e}}, journal={Physics reports}, volume={470}, number={5-6}, pages={151–238}, year={2009}, publisher={Elsevier} }

source

State-Dependent Solvers

OrdinaryDiffEqLinear.LieEuler — Type
LieEuler(; krylov = false,
+            iop = 0)

Semilinear ODE solver Fourth order Magnus method approximated using Gauss-Legendre quadrature.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{blanes2009magnus, title={The Magnus expansion and some of its applications}, author={Blanes, Sergio and Casas, Fernando and Oteo, Jose-Angel and Ros, Jos{'e}}, journal={Physics reports}, volume={470}, number={5-6}, pages={151–238}, year={2009}, publisher={Elsevier} }

source

State-Dependent Solvers

OrdinaryDiffEqLinear.LieEuler — Type
LieEuler(; krylov = false,
            m = 30,
-           iop = 0)

Semilinear ODE solver description

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{celledoni2014introduction, title={An introduction to Lie group integrators–basics, new developments and applications}, author={Celledoni, Elena and Marthinsen, H{a}kon and Owren, Brynjulf}, journal={Journal of Computational Physics}, volume={257}, pages={1040–1061}, year={2014}, publisher={Elsevier} }

source
OrdinaryDiffEqLinear.RKMK2 — Type
RKMK2(; krylov = false,
+           iop = 0)

Semilinear ODE solver description

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{celledoni2014introduction, title={An introduction to Lie group integrators–basics, new developments and applications}, author={Celledoni, Elena and Marthinsen, H{a}kon and Owren, Brynjulf}, journal={Journal of Computational Physics}, volume={257}, pages={1040–1061}, year={2014}, publisher={Elsevier} }

source
OrdinaryDiffEqLinear.RKMK2 — Type
RKMK2(; krylov = false,
         m = 30,
-        iop = 0)

Semilinear ODE solver Second order Runge–Kutta–Munthe-Kaas method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{celledoni2014introduction, title={An introduction to Lie group integrators–basics, new developments and applications}, author={Celledoni, Elena and Marthinsen, H{a}kon and Owren, Brynjulf}, journal={Journal of Computational Physics}, volume={257}, pages={1040–1061}, year={2014}, publisher={Elsevier} }

source
OrdinaryDiffEqLinear.RKMK4 — Type
RKMK4(; krylov = false,
+        iop = 0)

Semilinear ODE solver Second order Runge–Kutta–Munthe-Kaas method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{celledoni2014introduction, title={An introduction to Lie group integrators–basics, new developments and applications}, author={Celledoni, Elena and Marthinsen, H{a}kon and Owren, Brynjulf}, journal={Journal of Computational Physics}, volume={257}, pages={1040–1061}, year={2014}, publisher={Elsevier} }

source
OrdinaryDiffEqLinear.RKMK4 — Type
RKMK4(; krylov = false,
         m = 30,
-        iop = 0)

Semilinear ODE solver Fourth order Runge–Kutta–Munthe-Kaas method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{celledoni2014introduction, title={An introduction to Lie group integrators–basics, new developments and applications}, author={Celledoni, Elena and Marthinsen, H{a}kon and Owren, Brynjulf}, journal={Journal of Computational Physics}, volume={257}, pages={1040–1061}, year={2014}, publisher={Elsevier} }

source
OrdinaryDiffEqLinear.LieRK4 — Type
LieRK4(; krylov = false,
+        iop = 0)

Semilinear ODE solver Fourth order Runge–Kutta–Munthe-Kaas method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{celledoni2014introduction, title={An introduction to Lie group integrators–basics, new developments and applications}, author={Celledoni, Elena and Marthinsen, H{a}kon and Owren, Brynjulf}, journal={Journal of Computational Physics}, volume={257}, pages={1040–1061}, year={2014}, publisher={Elsevier} }

source
OrdinaryDiffEqLinear.LieRK4 — Type
LieRK4(; krylov = false,
          m = 30,
-         iop = 0)

Semilinear ODE solver Fourth order Lie Runge-Kutta method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{celledoni2014introduction, title={An introduction to Lie group integrators–basics, new developments and applications}, author={Celledoni, Elena and Marthinsen, H{a}kon and Owren, Brynjulf}, journal={Journal of Computational Physics}, volume={257}, pages={1040–1061}, year={2014}, publisher={Elsevier} }

source
OrdinaryDiffEqLinear.CG2 — Type
CG2(; krylov = false,
+         iop = 0)

Semilinear ODE solver Fourth order Lie Runge-Kutta method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{celledoni2014introduction, title={An introduction to Lie group integrators–basics, new developments and applications}, author={Celledoni, Elena and Marthinsen, H{a}kon and Owren, Brynjulf}, journal={Journal of Computational Physics}, volume={257}, pages={1040–1061}, year={2014}, publisher={Elsevier} }

source
OrdinaryDiffEqLinear.CG2 — Type
CG2(; krylov = false,
       m = 30,
-      iop = 0)

Semilinear ODE solver Second order Crouch–Grossman method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{celledoni2014introduction, title={An introduction to Lie group integrators–basics, new developments and applications}, author={Celledoni, Elena and Marthinsen, H{a}kon and Owren, Brynjulf}, journal={Journal of Computational Physics}, volume={257}, pages={1040–1061}, year={2014}, publisher={Elsevier} }

source
OrdinaryDiffEqLinear.CG4a — Type
CG4a(; krylov = false,
+      iop = 0)

Semilinear ODE solver Second order Crouch–Grossman method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{celledoni2014introduction, title={An introduction to Lie group integrators–basics, new developments and applications}, author={Celledoni, Elena and Marthinsen, H{a}kon and Owren, Brynjulf}, journal={Journal of Computational Physics}, volume={257}, pages={1040–1061}, year={2014}, publisher={Elsevier} }

source
OrdinaryDiffEqLinear.CG4a — Type
CG4a(; krylov = false,
        m = 30,
-       iop = 0)

Semilinear ODE solver Fourth order Crouch-Grossman method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{jackiewicz2000construction, title={Construction of Runge–Kutta methods of Crouch–Grossman type of high order}, author={Jackiewicz, Zdzislaw and Marthinsen, Arne and Owren, Brynjulf}, journal={Advances in Computational Mathematics}, volume={13}, pages={405–415}, year={2000}, publisher={Springer} }

source
OrdinaryDiffEqLinear.MagnusAdapt4 — Type
MagnusAdapt4()

Semilinear ODE solver Fourth Order Adaptive Magnus method.

Keyword Arguments

References

@article{li2008adaptive, title={Adaptive explicit Magnus numerical method for nonlinear dynamical systems}, author={Li, Wen-cheng and Deng, Zi-chen}, journal={Applied Mathematics and Mechanics}, volume={29}, number={9}, pages={1111–1118}, year={2008}, publisher={Springer}}

source
OrdinaryDiffEqLinear.CayleyEuler — Type
CayleyEuler()

Semilinear ODE solver First order method using Cayley transformations.

Keyword Arguments

References

@article{iserles2000lie, title={Lie-group methods}, author={Iserles, Arieh and Munthe-Kaas, Hans Z and Norsett, Syvert P and Zanna, Antonella}, journal={Acta numerica}, volume={9}, pages={215–365}, year={2000}, publisher={Cambridge University Press}}

source

Time and State-Dependent Operators

OrdinaryDiffEqLinear.CG3 — Type
CG3(; krylov = false,
+       iop = 0)

Semilinear ODE solver Fourth order Crouch-Grossman method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{jackiewicz2000construction, title={Construction of Runge–Kutta methods of Crouch–Grossman type of high order}, author={Jackiewicz, Zdzislaw and Marthinsen, Arne and Owren, Brynjulf}, journal={Advances in Computational Mathematics}, volume={13}, pages={405–415}, year={2000}, publisher={Springer} }

source
OrdinaryDiffEqLinear.MagnusAdapt4 — Type
MagnusAdapt4()

Semilinear ODE solver Fourth Order Adaptive Magnus method.

Keyword Arguments

References

@article{li2008adaptive, title={Adaptive explicit Magnus numerical method for nonlinear dynamical systems}, author={Li, Wen-cheng and Deng, Zi-chen}, journal={Applied Mathematics and Mechanics}, volume={29}, number={9}, pages={1111–1118}, year={2008}, publisher={Springer}}

source
OrdinaryDiffEqLinear.CayleyEuler — Type
CayleyEuler()

Semilinear ODE solver First order method using Cayley transformations.

Keyword Arguments

References

@article{iserles2000lie, title={Lie-group methods}, author={Iserles, Arieh and Munthe-Kaas, Hans Z and Norsett, Syvert P and Zanna, Antonella}, journal={Acta numerica}, volume={9}, pages={215–365}, year={2000}, publisher={Cambridge University Press}}

source

Time and State-Dependent Operators

OrdinaryDiffEqLinear.CG3 — Type
CG3(; krylov = false,
       m = 30,
-      iop = 0)

Semilinear ODE solver Third order Crouch-Grossman method.

Keyword Arguments

  • krylov: Determines whether Krylov approximation or operator caching is used, the latter only available for semilinear problems. krylov=true is much faster for larger systems and is thus recommended whenever there are >100 ODEs.
  • m: Controls the size of Krylov subspace.
  • iop: If not zero, determines the length of the incomplete orthogonalization procedure (IOP). Note that if the linear operator/Jacobian is hermitian, then the Lanczos algorithm will always be used and the IOP setting is ignored.

References

@article{crouch1993numerical, title={Numerical integration of ordinary differential equations on manifolds}, author={Crouch, Peter E and Grossman, R}, journal={Journal of Nonlinear Science}, volume={3}, pages={1–33}, year={1993}, publisher={Springer} }

source
+ iop = 0)

Semilinear ODE solver Third order Crouch-Grossman method.

Keyword Arguments

References

@article{crouch1993numerical, title={Numerical integration of ordinary differential equations on manifolds}, author={Crouch, Peter E and Grossman, R}, journal={Journal of Nonlinear Science}, volume={3}, pages={1–33}, year={1993}, publisher={Springer} }

source
diff --git a/dev/usage/index.html b/dev/usage/index.html index 42ca4d41e4..a36a4dcec1 100644 --- a/dev/usage/index.html +++ b/dev/usage/index.html @@ -39,4 +39,4 @@ initial_positions = [0.0, 0.1] initial_velocities = [0.5, 0.0] prob = SecondOrderODEProblem(HH_acceleration, initial_velocities, initial_positions, tspan) -sol2 = solve(prob, KahanLi8(), dt = 1 / 10);

Other refined forms are IMEX and semi-linear ODEs (for exponential integrators).

Available Solvers

For the list of available solvers, please refer to the DifferentialEquations.jl ODE Solvers, Dynamical ODE Solvers, and the Split ODE Solvers pages.

+sol2 = solve(prob, KahanLi8(), dt = 1 / 10);

Other refined forms are IMEX and semi-linear ODEs (for exponential integrators).

Available Solvers

For the list of available solvers, please refer to the DifferentialEquations.jl ODE Solvers, Dynamical ODE Solvers, and the Split ODE Solvers pages.