Missing docstring for DImplicitEuler. Check Documenter's build log for details.
Missing docstring for DABDF2. Check Documenter's build log for details.
Missing docstring for DFBDF. Check Documenter's build log for details.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.IRKN3 — TypeIRKN3Improved Runge-Kutta-Nyström method of order three, which minimizes the amount of evaluated functions in each step. Fixed time steps only.
Second order ODE should not depend on the first derivative.
References
@article{rabiei2012numerical, title={Numerical Solution of Second-Order Ordinary Differential Equations by Improved Runge-Kutta Nystrom Method}, author={Rabiei, Faranak and Ismail, Fudziah and Norazak, S and Emadi, Saeid}, publisher={Citeseer} }
OrdinaryDiffEq.IRKN4 — TypeIRKN4Improves Runge-Kutta-Nyström method of order four, which minimizes the amount of evaluated functions in each step. Fixed time steps only.
Second order ODE should not be dependent on the first derivative.
Recommended for smooth problems with expensive functions to evaluate.
References
@article{rabiei2012numerical, title={Numerical Solution of Second-Order Ordinary Differential Equations by Improved Runge-Kutta Nystrom Method}, author={Rabiei, Faranak and Ismail, Fudziah and Norazak, S and Emadi, Saeid}, publisher={Citeseer} }
OrdinaryDiffEq.Nystrom4 — TypeNystrom4A 4th order explicit Runge-Kutta-Nyström method which can be applied directly on second order ODEs. Can only be used with fixed time steps.
In case the ODE Problem is not dependent on the first derivative consider using Nystrom4VelocityIndependent to increase performance.
References
E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.
OrdinaryDiffEq.Nystrom4VelocityIndependent — TypeNystrom4VelocityIdependentA 4th order explicit Runkge-Kutta-Nyström method. Used directly on second order ODEs, where the acceleration is independent from velocity (ODE Problem is not dependent on the first derivative).
More efficient then Nystrom4 on velocity independent problems, since less evaluations are needed.
Fixed time steps only.
References
E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.
OrdinaryDiffEq.Nystrom5VelocityIndependent — TypeNystrom5VelocityIndependentA 5th order explicit Runkge-Kutta-Nyström method. Used directly on second order ODEs, where the acceleration is independent from velocity (ODE Problem is not dependent on the first derivative). Fixed time steps only.
References
E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.
OrdinaryDiffEq.FineRKN4 — TypeFineRKN4()A 4th order explicit Runge-Kutta-Nyström method which can be applied directly to second order ODEs. In particular, this method allows the acceleration equation to depend on the velocity.
References
@article{fine1987low,
+ title={Low order practical {R}unge-{K}utta-{N}ystr{"o}m methods},
+ author={Fine, Jerry Michael},
+ journal={Computing},
+ volume={38},
+ number={4},
+ pages={281--297},
+ year={1987},
+ publisher={Springer}
+}OrdinaryDiffEq.FineRKN5 — TypeFineRKN5()A 5th order explicit Runge-Kutta-Nyström method which can be applied directly to second order ODEs. In particular, this method allows the acceleration equation to depend on the velocity.
References
@article{fine1987low,
+ title={Low order practical {R}unge-{K}utta-{N}ystr{"o}m methods},
+ author={Fine, Jerry Michael},
+ journal={Computing},
+ volume={38},
+ number={4},
+ pages={281--297},
+ year={1987},
+ publisher={Springer}
+}OrdinaryDiffEq.DPRKN6 — TypeDPRKN66th order explicit Runge-Kutta-Nyström method. The second order ODE should not depend on the first derivative. Free 6th order interpolant.
References
@article{dormand1987runge, title={Runge-kutta-nystrom triples}, author={Dormand, JR and Prince, PJ}, journal={Computers \& Mathematics with Applications}, volume={13}, number={12}, pages={937–949}, year={1987}, publisher={Elsevier} }
OrdinaryDiffEq.DPRKN6FM — TypeDPRKN6FM6th order explicit Runge-Kutta-Nyström method. The second order ODE should not depend on the first derivative.
Compared to DPRKN6, this method has smaller truncation error coefficients which leads to performance gain when only the main solution points are considered.
References
@article{Dormand1987FamiliesOR, title={Families of Runge-Kutta-Nystrom Formulae}, author={J. R. Dormand and Moawwad E. A. El-Mikkawy and P. J. Prince}, journal={Ima Journal of Numerical Analysis}, year={1987}, volume={7}, pages={235-250} }
OrdinaryDiffEq.DPRKN8 — TypeDPRKN88th order explicit Runge-Kutta-Nyström method. The second order ODE should not depend on the first derivative.
Not as efficient as DPRKN12 when high accuracy is needed, however this solver is competitive with DPRKN6 at lax tolerances and, depending on the problem, might be a good option between performance and accuracy.
References
@article{dormand1987high, title={High-order embedded Runge-Kutta-Nystrom formulae}, author={Dormand, JR and El-Mikkawy, MEA and Prince, PJ}, journal={IMA Journal of Numerical Analysis}, volume={7}, number={4}, pages={423–430}, year={1987}, publisher={Oxford University Press} }
OrdinaryDiffEq.DPRKN12 — TypeDPRKN1212th order explicit Rugne-Kutta-Nyström method. The second order ODE should not depend on the first derivative.
Most efficient when high accuracy is needed.
References
@article{dormand1987high, title={High-order embedded Runge-Kutta-Nystrom formulae}, author={Dormand, JR and El-Mikkawy, MEA and Prince, PJ}, journal={IMA Journal of Numerical Analysis}, volume={7}, number={4}, pages={423–430}, year={1987}, publisher={Oxford University Press} }
OrdinaryDiffEq.ERKN4 — TypeERKN4Embedded 4(3) pair of explicit Runge-Kutta-Nyström methods. Integrates the periodic properties of the harmonic oscillator exactly.
The second order ODE should not depend on the first derivative.
Uses adaptive step size control. This method is extra efficient on periodic problems.
References
@article{demba2017embedded, title={An Embedded 4 (3) Pair of Explicit Trigonometrically-Fitted Runge-Kutta-Nystr{"o}m Method for Solving Periodic Initial Value Problems}, author={Demba, MA and Senu, N and Ismail, F}, journal={Applied Mathematical Sciences}, volume={11}, number={17}, pages={819–838}, year={2017} }
OrdinaryDiffEq.ERKN5 — TypeERKN5Embedded 5(4) pair of explicit Runge-Kutta-Nyström methods. Integrates the periodic properties of the harmonic oscillator exactly.
The second order ODE should not depend on the first derivative.
Uses adaptive step size control. This method is extra efficient on periodic problems.
References
@article{demba20165, title={A 5 (4) Embedded Pair of Explicit Trigonometrically-Fitted Runge–Kutta–Nystr{"o}m Methods for the Numerical Solution of Oscillatory Initial Value Problems}, author={Demba, Musa A and Senu, Norazak and Ismail, Fudziah}, journal={Mathematical and Computational Applications}, volume={21}, number={4}, pages={46}, year={2016}, publisher={Multidisciplinary Digital Publishing Institute} }
OrdinaryDiffEq.ERKN7 — TypeERKN7Embedded pair of explicit Runge-Kutta-Nyström methods. Integrates the periodic properties of the harmonic oscillator exactly.
The second order ODE should not depend on the first derivative.
Uses adaptive step size control. This method is extra efficient on periodic Problems.
References
@article{SimosOnHO, title={On high order Runge-Kutta-Nystr{"o}m pairs}, author={Theodore E. Simos and Ch. Tsitouras}, journal={J. Comput. Appl. Math.}, volume={400}, pages={113753} }
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
Missing docstring for SymplecticEuler. Check Documenter's build log for details.
OrdinaryDiffEq.VelocityVerlet — Type@article{verlet1967computer, title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, author={Verlet, Loup}, journal={Physical review}, volume={159}, number={1}, pages={98}, year={1967}, publisher={APS} }
OrdinaryDiffEq.VerletLeapfrog — Type@article{verlet1967computer, title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, author={Verlet, Loup}, journal={Physical review}, volume={159}, number={1}, pages={98}, year={1967}, publisher={APS} }
OrdinaryDiffEq.PseudoVerletLeapfrog — Type@article{verlet1967computer, title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, author={Verlet, Loup}, journal={Physical review}, volume={159}, number={1}, pages={98}, year={1967}, publisher={APS} }
OrdinaryDiffEq.McAte2 — Type@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }
OrdinaryDiffEq.Ruth3 — Type@article{ruth1983canonical, title={A canonical integration technique}, author={Ruth, Ronald D}, journal={IEEE Trans. Nucl. Sci.}, volume={30}, number={CERN-LEP-TH-83-14}, pages={2669–2671}, year={1983} }
OrdinaryDiffEq.McAte3 — Type@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }
OrdinaryDiffEq.CandyRoz4 — Type@article{candy1991symplectic, title={A symplectic integration algorithm for separable Hamiltonian functions}, author={Candy, J and Rozmus, W}, journal={Journal of Computational Physics}, volume={92}, number={1}, pages={230–256}, year={1991}, publisher={Elsevier} }
Missing docstring for McAte4. Check Documenter's build log for details.
OrdinaryDiffEq.CalvoSanz4 — Type@article{sanz1993symplectic, title={Symplectic numerical methods for Hamiltonian problems}, author={Sanz-Serna, Jes{'u}s Maria and Calvo, Mari-Paz}, journal={International Journal of Modern Physics C}, volume={4}, number={02}, pages={385–392}, year={1993}, publisher={World Scientific} }
OrdinaryDiffEq.McAte42 — Type@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }
OrdinaryDiffEq.McAte5 — Type@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }
OrdinaryDiffEq.Yoshida6 — Type@article{yoshida1990construction, title={Construction of higher order symplectic integrators}, author={Yoshida, Haruo}, journal={Physics letters A}, volume={150}, number={5-7}, pages={262–268}, year={1990}, publisher={Elsevier} }
OrdinaryDiffEq.KahanLi6 — Type@article{kahan1997composition, title={Composition constants for raising the orders of unconventional schemes for ordinary differential equations}, author={Kahan, William and Li, Ren-Cang}, journal={Mathematics of computation}, volume={66}, number={219}, pages={1089–1099}, year={1997} }
OrdinaryDiffEq.McAte8 — Type@article{mclachlan1995numerical, title={On the numerical integration of ordinary differential equations by symmetric composition methods}, author={McLachlan, Robert I}, journal={SIAM Journal on Scientific Computing}, volume={16}, number={1}, pages={151–168}, year={1995}, publisher={SIAM} }
OrdinaryDiffEq.KahanLi8 — Type@article{kahan1997composition, title={Composition constants for raising the orders of unconventional schemes for ordinary differential equations}, author={Kahan, William and Li, Ren-Cang}, journal={Mathematics of computation}, volume={66}, number={219}, pages={1089–1099}, year={1997} }
OrdinaryDiffEq.SofSpa10 — Type@article{sofroniou2005derivation, title={Derivation of symmetric composition constants for symmetric integrators}, author={Sofroniou, Mark and Spaletta, Giulia}, journal={Optimization Methods and Software}, volume={20}, number={4-5}, pages={597–613}, year={2005}, publisher={Taylor \& Francis} }
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
Missing docstring for CNAB2. Check Documenter's build log for details.
Missing docstring for CNLF2. Check Documenter's build log for details.
Missing docstring for SBDF. Check Documenter's build log for details.
OrdinaryDiffEq.SBDF2 — FunctionSBDF2(;kwargs...)The two-step version of the IMEX multistep methods of
See also SBDF.
OrdinaryDiffEq.SBDF3 — FunctionSBDF3(;kwargs...)The three-step version of the IMEX multistep methods of
See also SBDF.
OrdinaryDiffEq.SBDF4 — FunctionSBDF4(;kwargs...)The four-step version of the IMEX multistep methods of
See also SBDF.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.IMEXEuler — FunctionIMEXEuler(;kwargs...)The one-step version of the IMEX multistep methods of
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.
OrdinaryDiffEq.IMEXEulerARK — FunctionIMEXEulerARK(;kwargs...)The one-step version of the IMEX multistep methods of
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.
OrdinaryDiffEq.KenCarp3 — Type@book{kennedy2001additive, title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, author={Kennedy, Christopher Alan}, year={2001}, publisher={National Aeronautics and Space Administration, Langley Research Center} }
KenCarp3: SDIRK Method An A-L stable stiffly-accurate 3rd order ESDIRK method with splitting
OrdinaryDiffEq.KenCarp4 — Type@book{kennedy2001additive, title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, author={Kennedy, Christopher Alan}, year={2001}, publisher={National Aeronautics and Space Administration, Langley Research Center} }
KenCarp4: SDIRK Method An A-L stable stiffly-accurate 4th order ESDIRK method with splitting
OrdinaryDiffEq.KenCarp47 — Type@article{kennedy2019higher, title={Higher-order additive Runge–Kutta schemes for ordinary differential equations}, author={Kennedy, Christopher A and Carpenter, Mark H}, journal={Applied Numerical Mathematics}, volume={136}, pages={183–205}, year={2019}, publisher={Elsevier} }
KenCarp47: SDIRK Method An A-L stable stiffly-accurate 4th order seven-stage ESDIRK method with splitting
OrdinaryDiffEq.KenCarp5 — Type@book{kennedy2001additive, title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, author={Kennedy, Christopher Alan}, year={2001}, publisher={National Aeronautics and Space Administration, Langley Research Center} }
KenCarp5: SDIRK Method An A-L stable stiffly-accurate 5th order ESDIRK method with splitting
OrdinaryDiffEq.KenCarp58 — Type@article{kennedy2019higher, title={Higher-order additive Runge–Kutta schemes for ordinary differential equations}, author={Kennedy, Christopher A and Carpenter, Mark H}, journal={Applied Numerical Mathematics}, volume={136}, pages={183–205}, year={2019}, publisher={Elsevier} }
KenCarp58: SDIRK Method An A-L stable stiffly-accurate 5th order eight-stage ESDIRK method with splitting
Missing docstring for ESDIRK54I8L2SA. Check Documenter's build log for details.
OrdinaryDiffEq.ESDIRK436L2SA2 — Type@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244} }
OrdinaryDiffEq.ESDIRK437L2SA — Type@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244} }
OrdinaryDiffEq.ESDIRK547L2SA2 — Type@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244} }
OrdinaryDiffEq.ESDIRK659L2SA — Type@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244}
Currently has STABILITY ISSUES, causing it to fail the adaptive tests. Check issue https://github.com/SciML/OrdinaryDiffEq.jl/issues/1933 for more details. }
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.jl is a component package in the DifferentialEquations ecosystem. It holds the ordinary differential equation solvers and utilities. While completely independent and usable on its own, users interested in using this functionality should check out DifferentialEquations.jl.
Assuming that you already have Julia correctly installed, it suffices to import OrdinaryDiffEq.jl in the standard way:
import Pkg; Pkg.add("OrdinaryDiffEq")Status `~/work/OrdinaryDiffEq.jl/OrdinaryDiffEq.jl/docs/Project.toml`
+⌅ [e30172f5] Documenter v0.27.25
+ [1dea7af3] OrdinaryDiffEq v6.61.0 `~/work/OrdinaryDiffEq.jl/OrdinaryDiffEq.jl`
+Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated`Julia Version 1.9.4
+Commit 8e5136fa297 (2023-11-14 08:46 UTC)
+Build Info:
+ Official https://julialang.org/ release
+Platform Info:
+ OS: Linux (x86_64-linux-gnu)
+ CPU: 4 × AMD EPYC 7763 64-Core Processor
+ WORD_SIZE: 64
+ LIBM: libopenlibm
+ LLVM: libLLVM-14.0.6 (ORCJIT, znver3)
+ Threads: 1 on 4 virtual coresStatus `~/work/OrdinaryDiffEq.jl/OrdinaryDiffEq.jl/docs/Manifest.toml`
+ [47edcb42] ADTypes v0.2.5
+ [a4c015fc] ANSIColoredPrinters v0.0.1
+ [7d9f7c33] Accessors v0.1.33
+ [79e6a3ab] Adapt v3.7.2
+ [ec485272] ArnoldiMethod v0.2.0
+ [4fba245c] ArrayInterface v7.6.1
+ [4c555306] ArrayLayouts v1.4.3
+ [62783981] BitTwiddlingConvenienceFunctions v0.1.5
+ [2a0fbf3d] CPUSummary v0.2.4
+ [fb6a15b2] CloseOpenIntervals v0.1.12
+ [38540f10] CommonSolve v0.2.4
+ [bbf7d656] CommonSubexpressions v0.3.0
+ [34da2185] Compat v4.10.1
+ [a33af91c] CompositionsBase v0.1.2
+ [2569d6c7] ConcreteStructs v0.2.3
+ [187b0558] ConstructionBase v1.5.4
+ [adafc99b] CpuId v0.3.1
+ [9a962f9c] DataAPI v1.15.0
+ [864edb3b] DataStructures v0.18.15
+ [e2d170a0] DataValueInterfaces v1.0.0
+ [8bb1440f] DelimitedFiles v1.9.1
+ [2b5f629d] DiffEqBase v6.142.0
+ [163ba53b] DiffResults v1.1.0
+ [b552c78f] DiffRules v1.15.1
+ [ffbed154] DocStringExtensions v0.9.3
+⌅ [e30172f5] Documenter v0.27.25
+ [4e289a0a] EnumX v1.0.4
+ [f151be2c] EnzymeCore v0.6.4
+ [d4d017d3] ExponentialUtilities v1.25.0
+ [e2ba6199] ExprTools v0.1.10
+ [7034ab61] FastBroadcast v0.2.8
+ [9aa1b823] FastClosures v0.3.2
+ [29a986be] FastLapackInterface v2.0.0
+ [1a297f60] FillArrays v1.9.2
+ [6a86dc24] FiniteDiff v2.21.1
+ [f6369f11] ForwardDiff v0.10.36
+ [069b7b12] FunctionWrappers v1.1.3
+ [77dc65aa] FunctionWrappersWrappers v0.1.3
+ [46192b85] GPUArraysCore v0.1.5
+ [c145ed77] GenericSchur v0.5.3
+ [86223c79] Graphs v1.9.0
+ [3e5b6fbb] HostCPUFeatures v0.1.16
+ [b5f81e59] IOCapture v0.2.3
+ [615f187c] IfElse v0.1.1
+ [d25df0c9] Inflate v0.1.4
+ [18e54dd8] IntegerMathUtils v0.1.2
+ [3587e190] InverseFunctions v0.1.12
+ [92d709cd] IrrationalConstants v0.2.2
+ [82899510] IteratorInterfaceExtensions v1.0.0
+ [692b3bcd] JLLWrappers v1.5.0
+ [682c06a0] JSON v0.21.4
+ [ef3ab10e] KLU v0.4.1
+ [ba0b0d4f] Krylov v0.9.5
+ [73f95e8e] LatticeRules v0.0.1
+ [10f19ff3] LayoutPointers v0.1.15
+ [50d2b5c4] Lazy v0.15.1
+ [5078a376] LazyArrays v1.8.2
+ [d3d80556] LineSearches v7.2.0
+ [7ed4a6bd] LinearSolve v2.20.2
+ [2ab3a3ac] LogExpFunctions v0.3.26
+ [bdcacae8] LoopVectorization v0.12.166
+ [1914dd2f] MacroTools v0.5.11
+ [d125e4d3] ManualMemory v0.1.8
+ [a3b82374] MatrixFactorizations v2.1.0
+ [bb5d69b7] MaybeInplace v0.1.1
+ [e1d29d7a] Missings v1.1.0
+ [46d2c3a1] MuladdMacro v0.2.4
+ [d41bc354] NLSolversBase v7.8.3
+ [77ba4419] NaNMath v1.0.2
+ [8913a72c] NonlinearSolve v3.0.1
+ [6fe1bfb0] OffsetArrays v1.12.10
+ [bac558e1] OrderedCollections v1.6.3
+ [1dea7af3] OrdinaryDiffEq v6.61.0 `~/work/OrdinaryDiffEq.jl/OrdinaryDiffEq.jl`
+ [65ce6f38] PackageExtensionCompat v1.0.2
+ [d96e819e] Parameters v0.12.3
+ [69de0a69] Parsers v2.8.0
+ [f517fe37] Polyester v0.7.9
+ [1d0040c9] PolyesterWeave v0.2.1
+ [d236fae5] PreallocationTools v0.4.12
+ [aea7be01] PrecompileTools v1.2.0
+ [21216c6a] Preferences v1.4.1
+ [27ebfcd6] Primes v0.5.5
+ [8a4e6c94] QuasiMonteCarlo v0.3.3
+ [3cdcf5f2] RecipesBase v1.3.4
+ [731186ca] RecursiveArrayTools v2.38.10
+ [f2c3362d] RecursiveFactorization v0.2.21
+ [189a3867] Reexport v1.2.2
+ [ae029012] Requires v1.3.0
+ [7e49a35a] RuntimeGeneratedFunctions v0.5.12
+ [94e857df] SIMDTypes v0.1.0
+ [476501e8] SLEEFPirates v0.6.42
+ [0bca4576] SciMLBase v2.10.0
+ [c0aeaf25] SciMLOperators v0.3.7
+ [efcf1570] Setfield v1.1.1
+ [727e6d20] SimpleNonlinearSolve v1.0.2
+ [699a6c99] SimpleTraits v0.9.4
+ [ce78b400] SimpleUnPack v1.1.0
+ [ed01d8cd] Sobol v1.5.0
+ [a2af1166] SortingAlgorithms v1.2.0
+ [47a9eef4] SparseDiffTools v2.14.0
+ [e56a9233] Sparspak v0.3.9
+ [276daf66] SpecialFunctions v2.3.1
+ [aedffcd0] Static v0.8.8
+ [0d7ed370] StaticArrayInterface v1.4.1
+ [90137ffa] StaticArrays v1.7.0
+ [1e83bf80] StaticArraysCore v1.4.2
+ [82ae8749] StatsAPI v1.7.0
+ [2913bbd2] StatsBase v0.34.2
+ [7792a7ef] StrideArraysCore v0.5.2
+⌅ [2efcf032] SymbolicIndexingInterface v0.2.2
+ [3783bdb8] TableTraits v1.0.1
+ [bd369af6] Tables v1.11.1
+ [8290d209] ThreadingUtilities v0.5.2
+ [d5829a12] TriangularSolve v0.1.20
+ [410a4b4d] Tricks v0.1.8
+ [781d530d] TruncatedStacktraces v1.4.0
+ [3a884ed6] UnPack v1.0.2
+ [3d5dd08c] VectorizationBase v0.21.65
+ [19fa3120] VertexSafeGraphs v0.2.0
+ [1d5cc7b8] IntelOpenMP_jll v2024.0.0+0
+ [856f044c] MKL_jll v2024.0.0+0
+ [efe28fd5] OpenSpecFun_jll v0.5.5+0
+ [0dad84c5] ArgTools v1.1.1
+ [56f22d72] Artifacts
+ [2a0f44e3] Base64
+ [ade2ca70] Dates
+ [8ba89e20] Distributed
+ [f43a241f] Downloads v1.6.0
+ [7b1f6079] FileWatching
+ [9fa8497b] Future
+ [b77e0a4c] InteractiveUtils
+ [4af54fe1] LazyArtifacts
+ [b27032c2] LibCURL v0.6.4
+ [76f85450] LibGit2
+ [8f399da3] Libdl
+ [37e2e46d] LinearAlgebra
+ [56ddb016] Logging
+ [d6f4376e] Markdown
+ [a63ad114] Mmap
+ [ca575930] NetworkOptions v1.2.0
+ [44cfe95a] Pkg v1.9.2
+ [de0858da] Printf
+ [3fa0cd96] REPL
+ [9a3f8284] Random
+ [ea8e919c] SHA v0.7.0
+ [9e88b42a] Serialization
+ [1a1011a3] SharedArrays
+ [6462fe0b] Sockets
+ [2f01184e] SparseArrays
+ [10745b16] Statistics v1.9.0
+ [4607b0f0] SuiteSparse
+ [fa267f1f] TOML v1.0.3
+ [a4e569a6] Tar v1.10.0
+ [8dfed614] Test
+ [cf7118a7] UUIDs
+ [4ec0a83e] Unicode
+ [e66e0078] CompilerSupportLibraries_jll v1.0.5+0
+ [deac9b47] LibCURL_jll v8.4.0+0
+ [29816b5a] LibSSH2_jll v1.11.0+1
+ [c8ffd9c3] MbedTLS_jll v2.28.2+0
+ [14a3606d] MozillaCACerts_jll v2022.10.11
+ [4536629a] OpenBLAS_jll v0.3.21+4
+ [05823500] OpenLibm_jll v0.8.1+0
+ [bea87d4a] SuiteSparse_jll v5.10.1+6
+ [83775a58] Zlib_jll v1.2.13+0
+ [8e850b90] libblastrampoline_jll v5.8.0+0
+ [8e850ede] nghttp2_jll v1.52.0+1
+ [3f19e933] p7zip_jll v17.4.0+0
+Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m`Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
Missing docstring for LinearExponential. Check Documenter's build log for details.
Missing docstring for SplitEuler. Check Documenter's build log for details.
Missing docstring for CompositeAlgorithm. Check Documenter's build log for details.
OrdinaryDiffEq.PDIRK44 — TypePDIRK44: Parallel Diagonally Implicit Runge-Kutta Method A 2 processor 4th order diagonally non-adaptive implicit method.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.AitkenNeville — TypeAitkenNeville: Parallelized Explicit Extrapolation Method Euler extrapolation using Aitken-Neville with the Romberg Sequence.
OrdinaryDiffEq.ExtrapolationMidpointDeuflhard — TypeExtrapolationMidpointDeuflhard: Parallelized Explicit Extrapolation Method Midpoint extrapolation using Barycentric coordinates
OrdinaryDiffEq.ExtrapolationMidpointHairerWanner — TypeExtrapolationMidpointHairerWanner: Parallelized Explicit Extrapolation Method Midpoint extrapolation using Barycentric coordinates, following Hairer's ODEX in the adaptivity behavior.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
With the help of FastBroadcast.jl, we can use threaded parallelism to reduce compute time for all of the explicit Runge-Kutta methods! The thread option determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads. When we call solve(prob, alg(thread=OrdinaryDiffEq.True())), we can turn on the multithreading option to achieve acceleration (for sufficiently large problems).
OrdinaryDiffEq.Heun — TypeHeun(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. The second order Heun's method. Uses embedded Euler method for adaptivity.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.Ralston — TypeRalston(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. The optimized second order midpoint method. Uses embedded Euler method for adaptivity.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.Midpoint — TypeMidpoint(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. The second order midpoint method. Uses embedded Euler method for adaptivity.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.RK4 — TypeRK4(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. The canonical Runge-Kutta Order 4 method. Uses a defect control for adaptive stepping using maximum error over the whole interval.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
@article{shampine2005solving, title={Solving ODEs and DDEs with residual control}, author={Shampine, LF}, journal={Applied Numerical Mathematics}, volume={52}, number={1}, pages={113–127}, year={2005}, publisher={Elsevier} }
OrdinaryDiffEq.RKM — TypeRKM(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. TBD
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.MSRK5 — TypeMSRK5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. 5th order Explicit RK method.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Misha Stepanov - https://arxiv.org/pdf/2202.08443.pdf : Figure 3.
OrdinaryDiffEq.MSRK6 — TypeMSRK6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. 6th order Explicit RK method.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Misha Stepanov - https://arxiv.org/pdf/2202.08443.pdf : Table4
OrdinaryDiffEq.Anas5 — TypeAnas5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ w = 1)Explicit Runge-Kutta Method. 4th order Runge-Kutta method designed for periodic problems.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.w: a periodicity estimate, which when accurate the method becomes 5th order (and is otherwise 4th order with less error for better estimates).References
OrdinaryDiffEq.RKO65 — TypeRKO5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. 5th order Explicit RK method.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Tsitouras, Ch. "Explicit Runge–Kutta methods for starting integration of Lane–Emden problem." Applied Mathematics and Computation 354 (2019): 353-364. doi: https://doi.org/10.1016/j.amc.2019.02.047
OrdinaryDiffEq.OwrenZen3 — TypeOwrenZen3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 3/2 method (free 3rd order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
@article{owren1992derivation, title={Derivation of efficient, continuous, explicit Runge–Kutta methods}, author={Owren, Brynjulf and Zennaro, Marino}, journal={SIAM journal on scientific and statistical computing}, volume={13}, number={6}, pages={1488–1501}, year={1992}, publisher={SIAM} }
OrdinaryDiffEq.OwrenZen4 — TypeOwrenZen4(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 4/3 method (free 4th order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
@article{owren1992derivation, title={Derivation of efficient, continuous, explicit Runge–Kutta methods}, author={Owren, Brynjulf and Zennaro, Marino}, journal={SIAM journal on scientific and statistical computing}, volume={13}, number={6}, pages={1488–1501}, year={1992}, publisher={SIAM} }
OrdinaryDiffEq.OwrenZen5 — TypeOwrenZen5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 5/4 method (free 5th order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
@article{owren1992derivation, title={Derivation of efficient, continuous, explicit Runge–Kutta methods}, author={Owren, Brynjulf and Zennaro, Marino}, journal={SIAM journal on scientific and statistical computing}, volume={13}, number={6}, pages={1488–1501}, year={1992}, publisher={SIAM} }
OrdinaryDiffEq.BS3 — TypeBS3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, four-stage explicit FSAL Runge-Kutta method with embedded error estimator of Bogacki and Shampine.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
@article{bogacki19893, title={A 3 (2) pair of Runge-Kutta formulas}, author={Bogacki, Przemyslaw and Shampine, Lawrence F}, journal={Applied Mathematics Letters}, volume={2}, number={4}, pages={321–325}, year={1989}, publisher={Elsevier} }
OrdinaryDiffEq.DP5 — TypeDP5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Dormand-Prince's 5/4 Runge-Kutta method. (free 4th order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
@article{dormand1980family, title={A family of embedded Runge-Kutta formulae}, author={Dormand, John R and Prince, Peter J}, journal={Journal of computational and applied mathematics}, volume={6}, number={1}, pages={19–26}, year={1980}, publisher={Elsevier} }
OrdinaryDiffEq.Tsit5 — TypeTsit5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A fifth-order explicit Runge-Kutta method with embedded error estimator of Tsitouras. Free 4th order interpolant.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
@article{tsitouras2011runge, title={Runge–Kutta pairs of order 5 (4) satisfying only the first column simplifying assumption}, author={Tsitouras, Ch}, journal={Computers \& Mathematics with Applications}, volume={62}, number={2}, pages={770–775}, year={2011}, publisher={Elsevier} }
OrdinaryDiffEq.DP8 — TypeDP8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Hairer's 8/5/3 adaption of the Dormand-Prince Runge-Kutta method. (7th order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.
OrdinaryDiffEq.TanYam7 — TypeTanYam7(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Tanaka-Yamashita 7 Runge-Kutta method. (7th order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Tanaka M., Muramatsu S., Yamashita S., (1992), On the Optimization of Some Nine-Stage Seventh-order Runge-Kutta Method, Information Processing Society of Japan, 33 (12), pp. 1512-1526.
OrdinaryDiffEq.TsitPap8 — TypeTsitPap8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Tsitouras-Papakostas 8/7 Runge-Kutta method.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.Feagin10 — Type@article{feagin2012high, title={High-order explicit Runge-Kutta methods using m-symmetry}, author={Feagin, Terry}, year={2012}, publisher={Neural, Parallel \& Scientific Computations} }
Feagin10: Explicit Runge-Kutta Method Feagin's 10th-order Runge-Kutta method.
OrdinaryDiffEq.Feagin12 — Type@article{feagin2012high, title={High-order explicit Runge-Kutta methods using m-symmetry}, author={Feagin, Terry}, year={2012}, publisher={Neural, Parallel \& Scientific Computations} }
Feagin12: Explicit Runge-Kutta Method Feagin's 12th-order Runge-Kutta method.
OrdinaryDiffEq.Feagin14 — TypeFeagin, T., “An Explicit Runge-Kutta Method of Order Fourteen,” Numerical Algorithms, 2009
Feagin14: Explicit Runge-Kutta Method Feagin's 14th-order Runge-Kutta method.
OrdinaryDiffEq.FRK65 — TypeFRK65(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ omega = 0.0)Explicit Runge-Kutta Method. Zero Dissipation Runge-Kutta of 6th order.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.omega: a periodicity phase estimate, when accurate this method results in zero numerical dissipation.References
OrdinaryDiffEq.PFRK87 — TypePFRK87(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ omega = 0.0)Explicit Runge-Kutta Method. Phase-fitted Runge-Kutta of 8th order.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.omega: a periodicity phase estimate, when accurate this method results in zero numerical dissipation.References
OrdinaryDiffEq.Stepanov5 — TypeStepanov5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. 5th order Explicit RK method.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
@article{Stepanov2021Embedded5, title={Embedded (4, 5) pairs of explicit 7-stage Runge–Kutta methods with FSAL property}, author={Misha Stepanov}, journal={Calcolo}, year={2021}, volume={59} }
OrdinaryDiffEq.SIR54 — TypeSIR54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False())5th order Explicit RK method suited for SIR-type epidemic models.
Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).
The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
Reference
@article{Kovalnogov2020RungeKuttaPS, title={Runge–Kutta pairs suited for SIR‐type epidemic models}, author={Vladislav N. Kovalnogov and Theodore E. Simos and Ch. Tsitouras}, journal={Mathematical Methods in the Applied Sciences}, year={2020}, volume={44}, pages={5210 - 5216} }
OrdinaryDiffEq.Alshina2 — TypeAlshina2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False())2nd order, 2-stage Explicit Runge-Kutta Method with optimal parameters.
Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).
The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
Reference
@article{Alshina2008, doi = {10.1134/s0965542508030068}, url = {https://doi.org/10.1134/s0965542508030068}, year = {2008}, month = mar, publisher = {Pleiades Publishing Ltd}, volume = {48}, number = {3}, pages = {395–405}, author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, journal = {Computational Mathematics and Mathematical Physics} }
OrdinaryDiffEq.Alshina3 — TypeAlshina3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False())3rd order, 3-stage Explicit Runge-Kutta Method with optimal parameters.
Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).
The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
Reference
@article{Alshina2008, doi = {10.1134/s0965542508030068}, url = {https://doi.org/10.1134/s0965542508030068}, year = {2008}, month = mar, publisher = {Pleiades Publishing Ltd}, volume = {48}, number = {3}, pages = {395–405}, author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, journal = {Computational Mathematics and Mathematical Physics} }
OrdinaryDiffEq.Alshina6 — TypeAlshina6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False())6th order, 7-stage Explicit Runge-Kutta Method with optimal parameters.
Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).
The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
Reference
@article{Alshina2008, doi = {10.1134/s0965542508030068}, url = {https://doi.org/10.1134/s0965542508030068}, year = {2008}, month = mar, publisher = {Pleiades Publishing Ltd}, volume = {48}, number = {3}, pages = {395–405}, author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, journal = {Computational Mathematics and Mathematical Physics} }
OrdinaryDiffEq.BS5 — TypeBS5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ lazy = true)Explicit Runge-Kutta Method. Bogacki-Shampine 5/4 Runge-Kutta method. (lazy 5th order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.lazy: determines if the lazy interpolant is used.References
@article{bogacki1996efficient, title={An efficient runge-kutta (4, 5) pair}, author={Bogacki, P and Shampine, Lawrence F}, journal={Computers \& Mathematics with Applications}, volume={32}, number={6}, pages={15–28}, year={1996}, publisher={Elsevier} }
OrdinaryDiffEq.Vern6 — TypeVern6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ lazy = true)Explicit Runge-Kutta Method. Verner's “Most Efficient” 6/5 Runge-Kutta method. (lazy 6th order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.lazy: determines if the lazy interpolant is used.References
@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }
OrdinaryDiffEq.Vern7 — TypeVern7(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ lazy = true)Explicit Runge-Kutta Method. Verner's “Most Efficient” 7/6 Runge-Kutta method. (lazy 7th order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.lazy: determines if the lazy interpolant is used.References
@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }
OrdinaryDiffEq.Vern8 — TypeVern8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ lazy = true)Explicit Runge-Kutta Method. Verner's “Most Efficient” 8/7 Runge-Kutta method. (lazy 8th order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.lazy: determines if the lazy interpolant is used.References
@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }
OrdinaryDiffEq.Vern9 — TypeVern9(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ lazy = true)Explicit Runge-Kutta Method. Verner's “Most Efficient” 9/8 Runge-Kutta method. (lazy9th order interpolant).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.lazy: determines if the lazy interpolant is used.References
@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }
OrdinaryDiffEq.Euler — TypeEuler - The canonical forward Euler method. Fixed timestep only.
OrdinaryDiffEq.RK46NL — TypeRK46NL(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. 6-stage, fourth order low-stage, low-dissipation, low-dispersion scheme. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Julien Berland, Christophe Bogey, Christophe Bailly. Low-Dissipation and Low-Dispersion Fourth-Order Runge-Kutta Algorithm. Computers & Fluids, 35(10), pp 1459-1463, 2006. doi: https://doi.org/10.1016/j.compfluid.2005.04.003
OrdinaryDiffEq.ORK256 — TypeORK256(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ williamson_condition = true)Explicit Runge-Kutta Method. A second-order, five-stage explicit Runge-Kutta method for wave propagation equations. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.References
Matteo Bernardini, Sergio Pirozzoli. A General Strategy for the Optimization of Runge-Kutta Schemes for Wave Propagation Phenomena. Journal of Computational Physics, 228(11), pp 4182-4199, 2009. doi: https://doi.org/10.1016/j.jcp.2009.02.032
OrdinaryDiffEq.KuttaPRK2p5 — TypeKuttaPRK2p5: Parallel Explicit Runge-Kutta Method A 5 parallel, 2 processor explicit Runge-Kutta method of 5th order.
These methods utilize multithreading on the f calls to parallelize the problem. This requires that simultaneous calls to f are thread-safe.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.CarpenterKennedy2N54 — TypeCarpenterKennedy2N54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ williamson_condition = true)Explicit Runge-Kutta Method. A fourth-order, five-stage explicit low-storage method of Carpenter and Kennedy (free 3rd order Hermite interpolant). Fixed timestep only. Designed for hyperbolic PDEs (stability properties).
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.References
@article{carpenter1994fourth, title={Fourth-order 2N-storage Runge-Kutta schemes}, author={Carpenter, Mark H and Kennedy, Christopher A}, year={1994} }
OrdinaryDiffEq.SHLDDRK64 — TypeSHLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ williamson_condition = true)Explicit Runge-Kutta Method. A fourth-order, six-stage explicit low-storage method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.References
D. Stanescu, W. G. Habashi. 2N-Storage Low Dissipation and Dispersion Runge-Kutta Schemes for Computational Acoustics. Journal of Computational Physics, 143(2), pp 674-681, 1998. doi: https://doi.org/10.1006/jcph.1998.5986 }
OrdinaryDiffEq.SHLDDRK52 — TypeSHLDDRK52(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. TBD
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.SHLDDRK_2N — TypeSHLDDRK_2N(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. TBD
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.HSLDDRK64 — TypeHSLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ williamson_condition = true)Explicit Runge-Kutta Method. Low-Storage Method 6-stage, fourth order low-stage, low-dissipation, low-dispersion scheme. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.References
D. Stanescu, W. G. Habashi. 2N-Storage Low Dissipation and Dispersion Runge-Kutta Schemes for Computational Acoustics. Journal of Computational Physics, 143(2), pp 674-681, 1998. doi: https://doi.org/10.1006/jcph.1998.5986 }
OrdinaryDiffEq.DGLDDRK73_C — TypeDGLDDRK73_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ williamson_condition = true)Explicit Runge-Kutta Method. 7-stage, third order low-storage low-dissipation, low-dispersion scheme for discontinuous Galerkin space discretizations applied to wave propagation problems. Optimized for PDE discretizations when maximum spatial step is small due to geometric features of computational domain. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.References
T. Toulorge, W. Desmet. Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations Applied to Wave Propagation Problems. Journal of Computational Physics, 231(4), pp 2067-2091, 2012. doi: https://doi.org/10.1016/j.jcp.2011.11.024
OrdinaryDiffEq.DGLDDRK84_C — TypeDGLDDRK84_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ williamson_condition = true)Explicit Runge-Kutta Method. 8-stage, fourth order low-storage low-dissipation, low-dispersion scheme for discontinuous Galerkin space discretizations applied to wave propagation problems. Optimized for PDE discretizations when maximum spatial step is small due to geometric features of computational domain. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.References
T. Toulorge, W. Desmet. Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations Applied to Wave Propagation Problems. Journal of Computational Physics, 231(4), pp 2067-2091, 2012. doi: https://doi.org/10.1016/j.jcp.2011.11.024
OrdinaryDiffEq.DGLDDRK84_F — TypeDGLDDRK84_F(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ williamson_condition = true)Explicit Runge-Kutta Method. 8-stage, fourth order low-storage low-dissipation, low-dispersion scheme for discontinuous Galerkin space discretizations applied to wave propagation problems. Optimized for PDE discretizations when the maximum spatial step size is not constrained. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.References
T. Toulorge, W. Desmet. Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations Applied to Wave Propagation Problems. Journal of Computational Physics, 231(4), pp 2067-2091, 2012. doi: https://doi.org/10.1016/j.jcp.2011.11.024
OrdinaryDiffEq.NDBLSRK124 — TypeNDBLSRK124(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ williamson_condition = true)Explicit Runge-Kutta Method. 12-stage, fourth order low-storage method with optimized stability regions for advection-dominated problems. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.References
Jens Niegemann, Richard Diehl, Kurt Busch. Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions. Journal of Computational Physics, 231, pp 364-372, 2012. doi: https://doi.org/10.1016/j.jcp.2011.09.003
OrdinaryDiffEq.NDBLSRK134 — TypeNDBLSRK134(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ williamson_condition = true)Explicit Runge-Kutta Method. 13-stage, fourth order low-storage method with optimized stability regions for advection-dominated problems. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.References
Jens Niegemann, Richard Diehl, Kurt Busch. Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions. Journal of Computational Physics, 231, pp 364-372, 2012. doi: https://doi.org/10.1016/j.jcp.2011.09.003
OrdinaryDiffEq.NDBLSRK144 — TypeNDBLSRK144(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),
+ williamson_condition = true)Explicit Runge-Kutta Method. 14-stage, fourth order low-storage method with optimized stability regions for advection-dominated problems. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.References
Jens Niegemann, Richard Diehl, Kurt Busch. Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions. Journal of Computational Physics, 231, pp 364-372, 2012. doi: https://doi.org/10.1016/j.jcp.2011.09.003
OrdinaryDiffEq.CFRLDDRK64 — TypeCFRLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 6-stage, fourth order low-storage, low-dissipation, low-dispersion scheme. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
M. Calvo, J. M. Franco, L. Randez. A New Minimum Storage Runge–Kutta Scheme for Computational Acoustics. Journal of Computational Physics, 201, pp 1-12, 2004. doi: https://doi.org/10.1016/j.jcp.2004.05.012
OrdinaryDiffEq.TSLDDRK74 — TypeTSLDDRK74(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 7-stage, fourth order low-storage low-dissipation, low-dispersion scheme with maximal accuracy and stability limit along the imaginary axes. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Kostas Tselios, T. E. Simos. Optimized Runge–Kutta Methods with Minimal Dispersion and Dissipation for Problems arising from Computational Acoustics. Physics Letters A, 393(1-2), pp 38-47, 2007. doi: https://doi.org/10.1016/j.physleta.2006.10.072
OrdinaryDiffEq.CKLLSRK43_2 — TypeCKLLSRK43_2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 4-stage, third order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK54_3C — TypeCKLLSRK54_3C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK95_4S — TypeCKLLSRK95_4S(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK95_4C — TypeCKLLSRK95_4C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK95_4M — TypeCKLLSRK95_4M(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK54_3C_3R — TypeCKLLSRK54_3C_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK54_3M_3R — TypeCKLLSRK54_3M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK54_3N_3R — TypeCKLLSRK54_3N_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK85_4C_3R — TypeCKLLSRK85_4C_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK85_4M_3R — TypeCKLLSRK85_4M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK85_4P_3R — TypeCKLLSRK85_4P_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK54_3N_4R — TypeCKLLSRK54_3N_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK54_3M_4R — TypeCKLLSRK54_3M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK65_4M_4R — TypeCKLLSRK65_4M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. 6-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK85_4FM_4R — TypeCKLLSRK85_4FM_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.CKLLSRK75_4M_5R — TypeCKLLSRK75_4M_5R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. CKLLSRK754M5R: Low-Storage Method 7-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S32 — TypeParsaniKetchesonDeconinck3S32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 3-stage, second order (3S) low-storage scheme, optimized the spectral difference method applied to wave propagation problems.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S82 — TypeParsaniKetchesonDeconinck3S82(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 8-stage, second order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S53 — TypeParsaniKetchesonDeconinck3S53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 5-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S173 — TypeParsaniKetchesonDeconinck3S173(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 17-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S94 — TypeParsaniKetchesonDeconinck3S94(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S184 — TypeParsaniKetchesonDeconinck3S184(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 18-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S105 — TypeParsaniKetchesonDeconinck3S105(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 10-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S205 — TypeParsaniKetchesonDeconinck3S205(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. Low-Storage Method 20-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899
OrdinaryDiffEq.RDPK3Sp35 — TypeRDPK3Sp35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, five-stage explicit Runge-Kutta method with embedded error estimator designed for spectral element discretizations of compressible fluid mechanics.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836
OrdinaryDiffEq.RDPK3SpFSAL35 — TypeRDPK3SpFSAL35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, five-stage explicit Runge-Kutta method with embedded error estimator using the FSAL property designed for spectral element discretizations of compressible fluid mechanics.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836
OrdinaryDiffEq.RDPK3Sp49 — TypeRDPK3Sp49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A fourth-order, nine-stage explicit Runge-Kutta method with embedded error estimator designed for spectral element discretizations of compressible fluid mechanics.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836
OrdinaryDiffEq.RDPK3SpFSAL49 — TypeRDPK3SpFSAL49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A fourth-order, nine-stage explicit Runge-Kutta method with embedded error estimator using the FSAL property designed for spectral element discretizations of compressible fluid mechanics.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836
OrdinaryDiffEq.RDPK3Sp510 — TypeRDPK3Sp510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A fifth-order, ten-stage explicit Runge-Kutta method with embedded error estimator designed for spectral element discretizations of compressible fluid mechanics.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836
OrdinaryDiffEq.RDPK3SpFSAL510 — TypeRDPK3SpFSAL510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A fifth-order, ten-stage explicit Runge-Kutta method with embedded error estimator using the FSAL property designed for spectral element discretizations of compressible fluid mechanics.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836
OrdinaryDiffEq.KYK2014DGSSPRK_3S2 — TypeKYK2014DGSSPRK_3S2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. TBD
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.SSPRK22 — TypeSSPRK22(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A second-order, two-stage explicit strong stability preserving (SSP) method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Shu, Chi-Wang, and Stanley Osher. Efficient implementation of essentially non-oscillatory shock-capturing schemes. Journal of Computational Physics 77.2 (1988): 439-471. https://doi.org/10.1016/0021-9991(88)90177-5
OrdinaryDiffEq.SSPRK33 — TypeSSPRK33(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, three-stage explicit strong stability preserving (SSP) method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Shu, Chi-Wang, and Stanley Osher. Efficient implementation of essentially non-oscillatory shock-capturing schemes. Journal of Computational Physics 77.2 (1988): 439-471. https://doi.org/10.1016/0021-9991(88)90177-5
OrdinaryDiffEq.SSPRK53 — TypeSSPRK53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207
OrdinaryDiffEq.KYKSSPRK42 — TypeKYKSSPRK42(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. TBD
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
OrdinaryDiffEq.SSPRK53_2N1 — TypeSSPRK53_2N1(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Higueras and T. Roldán. New third order low-storage SSP explicit Runge–Kutta methods arXiv:1809.04807v1.
OrdinaryDiffEq.SSPRK53_2N2 — TypeSSPRK53_2N2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Higueras and T. Roldán. New third order low-storage SSP explicit Runge–Kutta methods arXiv:1809.04807v1.
OrdinaryDiffEq.SSPRK53_H — TypeSSPRK53_H(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Higueras and T. Roldán. New third order low-storage SSP explicit Runge–Kutta methods arXiv:1809.04807v1.
OrdinaryDiffEq.SSPRK63 — TypeSSPRK63(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, six-stage explicit strong stability preserving (SSP) method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207
OrdinaryDiffEq.SSPRK73 — TypeSSPRK73(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, seven-stage explicit strong stability preserving (SSP) method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207
OrdinaryDiffEq.SSPRK83 — TypeSSPRK83(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, eight-stage explicit strong stability preserving (SSP) method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207
OrdinaryDiffEq.SSPRK43 — TypeSSPRK43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, four-stage explicit strong stability preserving (SSP) method.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Optimal third-order explicit SSP method with four stages discovered by
Embedded method constructed by
Efficient implementation (and optimized controller) developed by
OrdinaryDiffEq.SSPRK432 — TypeSSPRK432(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, four-stage explicit strong stability preserving (SSP) method.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. Strong stability preserving Runge-Kutta and multistep time discretizations. World Scientific, 2011. Example 6.1
OrdinaryDiffEq.SSPRKMSVS43 — TypeSSPRKMSVS43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, four-step explicit strong stability preserving (SSP) linear multistep method. This method does not come with an error estimator and requires a fixed time step size.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Shu, Chi-Wang. Total-variation-diminishing time discretizations. SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. DOI: 10.1137/0909073
OrdinaryDiffEq.SSPRKMSVS32 — TypeSSPRKMSVS32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A second-order, three-step explicit strong stability preserving (SSP) linear multistep method. This method does not come with an error estimator and requires a fixed time step size.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Shu, Chi-Wang. Total-variation-diminishing time discretizations. SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. DOI: 10.1137/0909073
OrdinaryDiffEq.SSPRK932 — TypeSSPRK932(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A third-order, nine-stage explicit strong stability preserving (SSP) method.
Consider using SSPRK43 instead, which uses the same main method and an improved embedded method.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. Strong stability preserving Runge-Kutta and multistep time discretizations. World Scientific, 2011.
OrdinaryDiffEq.SSPRK54 — TypeSSPRK54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A fourth-order, five-stage explicit strong stability preserving (SSP) method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207.
OrdinaryDiffEq.SSPRK104 — TypeSSPRK104(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ step_limiter! = OrdinaryDiffEq.trivial_limiter!,
+ thread = OrdinaryDiffEq.False(),)Explicit Runge-Kutta Method. A fourth-order, ten-stage explicit strong stability preserving (SSP) method. Fixed timestep only.
Keyword Arguments
stage_limiter!: function of the form limiter!(u, integrator, p, t)step_limiter!: function of the form limiter!(u, integrator, p, t)thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.References
Ketcheson, David I. Highly efficient strong stability-preserving Runge–Kutta methods with low-storage implementations. SIAM Journal on Scientific Computing 30.4 (2008): 2113-2136.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.AB3 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
AB3: Adams-Bashforth Explicit Method The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values.
OrdinaryDiffEq.AB4 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
AB4: Adams-Bashforth Explicit Method The 4-step fourth order multistep method. Runge-Kutta method of order 4 is used to calculate starting values.
OrdinaryDiffEq.AB5 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
AB5: Adams-Bashforth Explicit Method The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values.
OrdinaryDiffEq.AN5 — TypeAN5: Adaptive step size Adams explicit Method An adaptive 5th order fixed-leading coefficient Adams method in Nordsieck form.
OrdinaryDiffEq.ABM32 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
ABM32: Adams-Bashforth Explicit Method It is third order method. In ABM32, AB3 works as predictor and Adams Moulton 2-steps method works as Corrector. Ralston's Second Order Method is used to calculate starting values.
OrdinaryDiffEq.ABM43 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
ABM43: Adams-Bashforth Explicit Method It is fourth order method. In ABM43, AB4 works as predictor and Adams Moulton 3-steps method works as Corrector. Runge-Kutta method of order 4 is used to calculate starting values.
OrdinaryDiffEq.ABM54 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
ABM54: Adams-Bashforth Explicit Method It is fifth order method. In ABM54, AB5 works as predictor and Adams Moulton 4-steps method works as Corrector. Runge-Kutta method of order 4 is used to calculate starting values.
OrdinaryDiffEq.VCAB3 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
VCAB3: Adaptive step size Adams explicit Method The 3rd order Adams method. Bogacki-Shampine 3/2 method is used to calculate starting values.
OrdinaryDiffEq.VCAB4 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
VCAB4: Adaptive step size Adams explicit Method The 4th order Adams method. Runge-Kutta 4 is used to calculate starting values.
OrdinaryDiffEq.VCAB5 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
VCAB5: Adaptive step size Adams explicit Method The 5th order Adams method. Runge-Kutta 4 is used to calculate starting values.
OrdinaryDiffEq.VCABM3 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
VCABM3: Adaptive step size Adams explicit Method The 3rd order Adams-Moulton method. Bogacki-Shampine 3/2 method is used to calculate starting values.
OrdinaryDiffEq.VCABM4 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
VCABM4: Adaptive step size Adams explicit Method The 4th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.
OrdinaryDiffEq.VCABM5 — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
VCABM5: Adaptive step size Adams explicit Method The 5th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.
OrdinaryDiffEq.VCABM — TypeE. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1
VCABM: Adaptive step size Adams explicit Method An adaptive order adaptive time Adams Moulton method. It uses an order adaptivity algorithm is derived from Shampine's DDEABM.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
Missing docstring for LawsonEuler. Check Documenter's build log for details.
Missing docstring for NorsettEuler. Check Documenter's build log for details.
OrdinaryDiffEq.ETD2 — TypeETD2: Exponential Runge-Kutta Method Second order Exponential Time Differencing method (in development).
Missing docstring for ETDRK2. Check Documenter's build log for details.
Missing docstring for ETDRK3. Check Documenter's build log for details.
Missing docstring for ETDRK4. Check Documenter's build log for details.
Missing docstring for HochOst4. Check Documenter's build log for details.
Missing docstring for Exp4. Check Documenter's build log for details.
Missing docstring for EPIRK4s3A. Check Documenter's build log for details.
Missing docstring for EPIRK4s3B. Check Documenter's build log for details.
Missing docstring for EPIRK5s3. Check Documenter's build log for details.
Missing docstring for EXPRB53s3. Check Documenter's build log for details.
Missing docstring for EPIRK5P1. Check Documenter's build log for details.
Missing docstring for EPIRK5P2. Check Documenter's build log for details.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
Missing docstring for MagnusMidpoint. Check Documenter's build log for details.
Missing docstring for MagnusLeapfrog. Check Documenter's build log for details.
Missing docstring for LieEuler. Check Documenter's build log for details.
Missing docstring for MagnusGauss4. Check Documenter's build log for details.
Missing docstring for MagnusNC6. Check Documenter's build log for details.
Missing docstring for MagnusGL6. Check Documenter's build log for details.
Missing docstring for MagnusGL8. Check Documenter's build log for details.
Missing docstring for MagnusNC8. Check Documenter's build log for details.
Missing docstring for MagnusGL4. Check Documenter's build log for details.
Missing docstring for RKMK2. Check Documenter's build log for details.
Missing docstring for RKMK4. Check Documenter's build log for details.
Missing docstring for LieRK4. Check Documenter's build log for details.
Missing docstring for CG2. Check Documenter's build log for details.
Missing docstring for CG3. Check Documenter's build log for details.
Missing docstring for CG4a. Check Documenter's build log for details.
Missing docstring for MagnusAdapt4. Check Documenter's build log for details.
Missing docstring for CayleyEuler. Check Documenter's build log for details.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.RadauIIA3 — Type@article{hairer1999stiff, title={Stiff differential equations solved by Radau methods}, author={Hairer, Ernst and Wanner, Gerhard}, journal={Journal of Computational and Applied Mathematics}, volume={111}, number={1-2}, pages={93–111}, year={1999}, publisher={Elsevier} }
RadauIIA3: Fully-Implicit Runge-Kutta Method An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency.
OrdinaryDiffEq.RadauIIA5 — Type@article{hairer1999stiff, title={Stiff differential equations solved by Radau methods}, author={Hairer, Ernst and Wanner, Gerhard}, journal={Journal of Computational and Applied Mathematics}, volume={111}, number={1-2}, pages={93–111}, year={1999}, publisher={Elsevier} }
RadauIIA5: Fully-Implicit Runge-Kutta Method An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.ImplicitEulerExtrapolation — TypeImplicitEulerExtrapolation: Parallelized Implicit Extrapolation Method Extrapolation of implicit Euler method with Romberg sequence. Similar to Hairer's SEULEX.
OrdinaryDiffEq.ImplicitDeuflhardExtrapolation — TypeImplicitDeuflhardExtrapolation: Parallelized Implicit Extrapolation Method Midpoint extrapolation using Barycentric coordinates
OrdinaryDiffEq.ImplicitHairerWannerExtrapolation — TypeImplicitHairerWannerExtrapolation: Parallelized Implicit Extrapolation Method Midpoint extrapolation using Barycentric coordinates, following Hairer's SODEX in the adaptivity behavior.
OrdinaryDiffEq.ImplicitEulerBarycentricExtrapolation — TypeImplicitEulerBarycentricExtrapolation: Parallelized Implicit Extrapolation Method Euler extrapolation using Barycentric coordinates, following Hairer's SODEX in the adaptivity behavior.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
Missing docstring for ROS3P. Check Documenter's build log for details.
Missing docstring for Rodas3. Check Documenter's build log for details.
Missing docstring for RosShamp4. Check Documenter's build log for details.
Missing docstring for Veldd4. Check Documenter's build log for details.
Missing docstring for Velds4. Check Documenter's build log for details.
Missing docstring for GRK4T. Check Documenter's build log for details.
Missing docstring for GRK4A. Check Documenter's build log for details.
Missing docstring for Ros4LStab. Check Documenter's build log for details.
Missing docstring for Rodas4. Check Documenter's build log for details.
Missing docstring for Rodas42. Check Documenter's build log for details.
Missing docstring for Rodas4P. Check Documenter's build log for details.
Missing docstring for Rodas4P2. Check Documenter's build log for details.
Missing docstring for Rodas5. Check Documenter's build log for details.
Missing docstring for Rodas5P. Check Documenter's build log for details.
Missing docstring for GeneralRosenbrock. Check Documenter's build log for details.
Missing docstring for Rosenbrock23. Check Documenter's build log for details.
Missing docstring for Rosenbrock32. Check Documenter's build log for details.
Missing docstring for ROS34PW1a. Check Documenter's build log for details.
Missing docstring for ROS34PW1b. Check Documenter's build log for details.
Missing docstring for ROS34PW2. Check Documenter's build log for details.
Missing docstring for ROS34PW3. Check Documenter's build log for details.
OrdinaryDiffEq.RosenbrockW6S4OS — TypeRosenbrockW6S4OS: Rosenbrock-W Method A 4th order L-stable Rosenbrock-W method (fixed step only).
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.ImplicitEuler — TypeImplicitEuler: SDIRK Method A 1st order implicit solver. A-B-L-stable. Adaptive timestepping through a divided differences estimate via memory. Strong-stability preserving (SSP).
OrdinaryDiffEq.ImplicitMidpoint — TypeImplicitMidpoint: SDIRK Method A second order A-stable symplectic and symmetric implicit solver. Good for highly stiff equations which need symplectic integration.
OrdinaryDiffEq.Trapezoid — TypeAndre Vladimirescu. 1994. The Spice Book. John Wiley & Sons, Inc., New York, NY, USA.
Trapezoid: SDIRK Method A second order A-stable symmetric ESDIRK method. "Almost symplectic" without numerical dampening. Also known as Crank-Nicolson when applied to PDEs. Adaptive timestepping via divided differences approximation to the second derivative terms in the local truncation error estimate (the SPICE approximation strategy).
OrdinaryDiffEq.TRBDF2 — Type@article{hosea1996analysis, title={Analysis and implementation of TR-BDF2}, author={Hosea, ME and Shampine, LF}, journal={Applied Numerical Mathematics}, volume={20}, number={1-2}, pages={21–37}, year={1996}, publisher={Elsevier} }
TRBDF2: SDIRK Method A second order A-B-L-S-stable one-step ESDIRK method. Includes stiffness-robust error estimates for accurate adaptive timestepping, smoothed derivatives for highly stiff and oscillatory problems.
OrdinaryDiffEq.SDIRK2 — Type@article{hindmarsh2005sundials, title={{SUNDIALS}: Suite of nonlinear and differential/algebraic equation solvers}, author={Hindmarsh, Alan C and Brown, Peter N and Grant, Keith E and Lee, Steven L and Serban, Radu and Shumaker, Dan E and Woodward, Carol S}, journal={ACM Transactions on Mathematical Software (TOMS)}, volume={31}, number={3}, pages={363–396}, year={2005}, publisher={ACM} }
SDIRK2: SDIRK Method An A-B-L stable 2nd order SDIRK method
Missing docstring for SDIRK22. Check Documenter's build log for details.
Missing docstring for SSPSDIRK2. Check Documenter's build log for details.
OrdinaryDiffEq.Kvaerno3 — Type@article{kvaerno2004singly, title={Singly diagonally implicit Runge–Kutta methods with an explicit first stage}, author={Kv{\ae}rn{\o}, Anne}, journal={BIT Numerical Mathematics}, volume={44}, number={3}, pages={489–502}, year={2004}, publisher={Springer} }
Kvaerno3: SDIRK Method An A-L stable stiffly-accurate 3rd order ESDIRK method
Missing docstring for CFNLIRK3. Check Documenter's build log for details.
OrdinaryDiffEq.Cash4 — Type@article{hindmarsh2005sundials, title={{SUNDIALS}: Suite of nonlinear and differential/algebraic equation solvers}, author={Hindmarsh, Alan C and Brown, Peter N and Grant, Keith E and Lee, Steven L and Serban, Radu and Shumaker, Dan E and Woodward, Carol S}, journal={ACM Transactions on Mathematical Software (TOMS)}, volume={31}, number={3}, pages={363–396}, year={2005}, publisher={ACM} }
Cash4: SDIRK Method An A-L stable 4th order SDIRK method
Missing docstring for SFSDIRK4. Check Documenter's build log for details.
Missing docstring for SFSDIRK5. Check Documenter's build log for details.
Missing docstring for SFSDIRK6. Check Documenter's build log for details.
Missing docstring for SFSDIRK7. Check Documenter's build log for details.
Missing docstring for SFSDIRK8. Check Documenter's build log for details.
OrdinaryDiffEq.Hairer4 — TypeE. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)
Hairer4: SDIRK Method An A-L stable 4th order SDIRK method
OrdinaryDiffEq.Hairer42 — TypeE. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)
Hairer42: SDIRK Method An A-L stable 4th order SDIRK method
OrdinaryDiffEq.Kvaerno4 — Type@article{kvaerno2004singly, title={Singly diagonally implicit Runge–Kutta methods with an explicit first stage}, author={Kv{\ae}rn{\o}, Anne}, journal={BIT Numerical Mathematics}, volume={44}, number={3}, pages={489–502}, year={2004}, publisher={Springer} }
Kvaerno4: SDIRK Method An A-L stable stiffly-accurate 4th order ESDIRK method.
OrdinaryDiffEq.Kvaerno5 — Type@article{kvaerno2004singly, title={Singly diagonally implicit Runge–Kutta methods with an explicit first stage}, author={Kv{\ae}rn{\o}, Anne}, journal={BIT Numerical Mathematics}, volume={44}, number={3}, pages={489–502}, year={2004}, publisher={Springer} }
Kvaerno5: SDIRK Method An A-L stable stiffly-accurate 5th order ESDIRK method
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
Explicit stabilized methods utilize an upper bound on the spectral radius of the Jacobian. Users can supply an upper bound by specifying the keyword argument eigen_est, for example
`eigen_est = (integrator) -> integrator.eigen_est = upper_bound`The methods ROCK2 and ROCK4 also include keyword arguments min_stages and max_stages, which specify upper and lower bounds on the adaptively chosen number of stages for stability.
OrdinaryDiffEq.ROCK2 — TypeAssyr Abdulle, Alexei A. Medovikov. Second Order Chebyshev Methods based on Orthogonal Polynomials. Numerische Mathematik, 90 (1), pp 1-18, 2001. doi: https://dx.doi.org/10.1007/s002110100292
ROCK2: Stabilized Explicit Method. Second order stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.
This method takes optional keyword arguments min_stages, max_stages, and eigen_est. The function eigen_est should be of the form
eigen_est = (integrator) -> integrator.eigen_est = upper_bound,
where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.
OrdinaryDiffEq.ROCK4 — TypeROCK4(; min_stages = 0, max_stages = 152, eigen_est = nothing)Assyr Abdulle. Fourth Order Chebyshev Methods With Recurrence Relation. 2002 Society for Industrial and Applied Mathematics Journal on Scientific Computing, 23(6), pp 2041-2054, 2001. doi: https://doi.org/10.1137/S1064827500379549
ROCK4: Stabilized Explicit Method. Fourth order stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.
This method takes optional keyword arguments min_stages, max_stages, and eigen_est. The function eigen_est should be of the form
eigen_est = (integrator) -> integrator.eigen_est = upper_bound,
where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.
Missing docstring for SERK2. Check Documenter's build log for details.
OrdinaryDiffEq.ESERK4 — TypeESERK4(; eigen_est = nothing)J. Martín-Vaquero, B. Kleefeld. Extrapolated stabilized explicit Runge-Kutta methods, Journal of Computational Physics, 326, pp 141-155, 2016. doi: https://doi.org/10.1016/j.jcp.2016.08.042.
ESERK4: Stabilized Explicit Method. Fourth order extrapolated stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.
This method takes the keyword argument eigen_est of the form
eigen_est = (integrator) -> integrator.eigen_est = upper_bound,
where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.
OrdinaryDiffEq.ESERK5 — TypeESERK5(; eigen_est = nothing)J. Martín-Vaquero, A. Kleefeld. ESERK5: A fifth-order extrapolated stabilized explicit Runge-Kutta method, Journal of Computational and Applied Mathematics, 356, pp 22-36, 2019. doi: https://doi.org/10.1016/j.cam.2019.01.040.
ESERK5: Stabilized Explicit Method. Fifth order extrapolated stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.
This method takes the keyword argument eigen_est of the form
eigen_est = (integrator) -> integrator.eigen_est = upper_bound,
where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.
OrdinaryDiffEq.RKC — TypeRKC(; eigen_est = nothing)B. P. Sommeijer, L. F. Shampine, J. G. Verwer. RKC: An Explicit Solver for Parabolic PDEs, Journal of Computational and Applied Mathematics, 88(2), pp 315-326, 1998. doi: https://doi.org/10.1016/S0377-0427(97)00219-7
RKC: Stabilized Explicit Method. Second order stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues.
This method takes the keyword argument eigen_est of the form
eigen_est = (integrator) -> integrator.eigen_est = upper_bound,
where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.
Missing docstring for IRKC. Check Documenter's build log for details.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.QNDF1 — TypeQNDF1: Multistep Method An adaptive order 1 quasi-constant timestep L-stable numerical differentiation function (NDF) method. Optional parameter kappa defaults to Shampine's accuracy-optimal -0.1850.
See also QNDF.
OrdinaryDiffEq.QBDF1 — FunctionQBDF1: Multistep Method
An alias of QNDF1 with κ=0.
OrdinaryDiffEq.QNDF2 — TypeQNDF2: Multistep Method An adaptive order 2 quasi-constant timestep L-stable numerical differentiation function (NDF) method.
See also QNDF.
OrdinaryDiffEq.QBDF2 — FunctionQBDF2: Multistep Method
An alias of QNDF2 with κ=0.
OrdinaryDiffEq.ABDF2 — TypeE. Alberdi Celayaa, J. J. Anza Aguirrezabalab, P. Chatzipantelidisc. Implementation of an Adaptive BDF2 Formula and Comparison with The MATLAB Ode15s. Procedia Computer Science, 29, pp 1014-1026, 2014. doi: https://doi.org/10.1016/j.procs.2014.05.091
ABDF2: Multistep Method An adaptive order 2 L-stable fixed leading coefficient multistep BDF method.
OrdinaryDiffEq.QNDF — TypeQNDF: Multistep Method An adaptive order quasi-constant timestep NDF method. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients).
@article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }
OrdinaryDiffEq.QBDF — FunctionQBDF: Multistep Method
An alias of QNDF with κ=0.
OrdinaryDiffEq.FBDF — TypeFBDF: Fixed leading coefficient BDF
An adaptive order quasi-constant timestep NDF method. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients).
@article{shampine2002solving, title={Solving 0= F (t, y (t), y′(t)) in Matlab}, author={Shampine, Lawrence F}, year={2002}, publisher={Walter de Gruyter GmbH \& Co. KG} }
OrdinaryDiffEq.MEBDF2 — TypeMEBDF2: Multistep Method The second order Modified Extended BDF method, which has improved stability properties over the standard BDF. Fixed timestep only.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.
OrdinaryDiffEq.jl is part of the SciML common interface, but can be used independently of DifferentialEquations.jl. The only requirement is that the user passes an OrdinaryDiffEq.jl algorithm to solve. For example, we can solve the ODE tutorial from the docs using the Tsit5() algorithm:
using OrdinaryDiffEq
+f(u,p,t) = 1.01*u
+u0=1/2
+tspan = (0.0,1.0)
+prob = ODEProblem(f,u0,tspan)
+sol = solve(prob,Tsit5(),reltol=1e-8,abstol=1e-8)
+using Plots
+plot(sol,linewidth=5,title="Solution to the linear ODE with a thick line",
+ xaxis="Time (t)",yaxis="u(t) (in μm)",label="My Thick Line!") # legend=false
+plot!(sol.t, t->0.5*exp(1.01t),lw=3,ls=:dash,label="True Solution!")That example uses the out-of-place syntax f(u,p,t), while the inplace syntax (more efficient for systems of equations) is shown in the Lorenz example:
using OrdinaryDiffEq
+function lorenz(du,u,p,t)
+ du[1] = 10.0(u[2]-u[1])
+ du[2] = u[1]*(28.0-u[3]) - u[2]
+ du[3] = u[1]*u[2] - (8/3)*u[3]
+end
+u0 = [1.0;0.0;0.0]
+tspan = (0.0,100.0)
+prob = ODEProblem(lorenz,u0,tspan)
+sol = solve(prob,Tsit5())
+using Plots; plot(sol,vars=(1,2,3))Very fast static array versions can be specifically compiled to the size of your model. For example:
using OrdinaryDiffEq, StaticArrays
+function lorenz(u,p,t)
+ SA[10.0(u[2]-u[1]),u[1]*(28.0-u[3]) - u[2],u[1]*u[2] - (8/3)*u[3]]
+end
+u0 = SA[1.0;0.0;0.0]
+tspan = (0.0,100.0)
+prob = ODEProblem(lorenz,u0,tspan)
+sol = solve(prob,Tsit5())For “refined ODEs”, like dynamical equations and SecondOrderODEProblems, refer to the DiffEqDocs. For example, in DiffEqTutorials.jl we show how to solve equations of motion using symplectic methods:
function HH_acceleration(dv,v,u,p,t)
+ x,y = u
+ dx,dy = dv
+ dv[1] = -x - 2x*y
+ dv[2] = y^2 - y -x^2
+end
+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).
For the list of available solvers, please refer to the DifferentialEquations.jl ODE Solvers, Dynamical ODE Solvers, and the Split ODE Solvers pages.
Settings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 12 December 2023. Using Julia version 1.9.4.