GitHub

ODE Tableaus

Explicit Runge-Kutta Methods

  • constructEuler - Euler's 1st order method.
  • constructHeun() Heun's order 2 method.
  • constructRalston() - Ralston's order 2 method.
  • constructSSPRK22() - Explicit SSP method of order 2 using 2 stages.
  • constructKutta3 - Kutta's classic 3rd order method.
  • constructSSPRK33() - Explicit SSP method of order 3 using 3 stages.
  • constructSSPRK43() - Explicit SSP method of order 3 using 4 stages.
  • constructRK4 - The classic 4th order "Runge-Kutta" method.
  • constructRK438Rule - The classic 4th order "3/8th's Rule" method.
  • constructSSPRK104() - Explicit SSP method of order 4 using 10 stages.
  • constructBogakiShampine3() - Bogakai-Shampine's 2/3 method.
  • constructRKF4() - Runge-Kutta-Fehlberg 3/4.
  • constructRKF5() - Runge-Kutta-Fehlberg 4/5.
  • constructRungeFirst5() - Runge's first 5th order method.
  • constructCassity5() - Cassity's 5th order method.
  • constructLawson5() - Lawson's 5th order method.
  • constructLutherKonen5 - Luther-Konen's first 5th order method.
  • constructLutherKonen52() - Luther-Konen's second 5th order method.
  • constructLutherKonen53() - Luther-Konen's third 5th order method.
  • constructPapakostasPapaGeorgiou5() - Papakostas and PapaGeorgiou more stable order 5 method.
  • constructPapakostasPapaGeorgiou52() - Papakostas and PapaGeorgiou more efficient order 5 method.
  • constructTsitouras5() - Tsitouras's order 5 method.
  • constructBogakiShampine5() - Bogaki and Shampine's Order 5 method.
  • constructSharpSmart5() - Sharp and Smart's Order 5 method.
  • constructCashKarp() - Cash-Karp method 4/5.
  • constructDormandPrince() - Dormand-Prince 4/5.
  • constructButcher6() - Butcher's first order 6 method.
  • constructButcher62() - Butcher's second order 6 method.
  • constructButcher63() - Butcher's third order 6 method.
  • constructDormandPrince6() - Dormand-Prince's 5/6 method.
  • constructSharpVerner6() Sharp-Verner's 5/6 method.
  • constructVerner916() - Verner's more efficient order 6 method (1991).
  • constructVerner9162() - Verner's second more efficient order 6 method (1991).
  • constructVernerRobust6() - Verner's "most robust" order 6 method.
  • constructVernerEfficient6() - Verner's "most efficient" order 6 method.
  • constructPapakostas6() - Papakostas's order 6 method.
  • constructLawson6() - Lawson's order 6 method.
  • constructTsitourasPapakostas6() - Tsitouras and Papakostas's order 6 method.
  • constructDormandLockyerMcCorriganPrince6() - the Dormand-Lockyer-McCorrigan-Prince order 6 method.
  • constructTanakaKasugaYamashitaYazaki6A() - Tanaka-Kasuga-Yamashita-Yazaki order 6 method A.
  • constructTanakaKasugaYamashitaYazaki6B() - Tanaka-Kasuga-Yamashita-Yazaki order 6 method B.
  • constructTanakaKasugaYamashitaYazaki6C() - Tanaka-Kasuga-Yamashita-Yazaki order 6 method C.
  • constructTanakaKasugaYamashitaYazaki6D() - Tanaka-Kasuga-Yamashita-Yazaki order 6 method D.
  • constructMikkawyEisa() - Mikkawy and Eisa's order 6 method.
  • constructChummund6() - Chummund's first order 6 method.
  • constructChummund62() - Chummund's second order 6 method.
  • constructHuta6() - Huta's first order 6 method.
  • constructHuta62() - Huta's second order 6 method.
  • constructVerner6() - An old order 6 method attributed to Verner.
  • constructDverk() - The classic DVERK algorithm attributed to Verner.
  • constructClassicVerner6() - A classic Verner order 6 algorithm (1978).
  • constructButcher7() - Butcher's order 7 algorithm.
  • constructClassicVerner7()- A classic Verner order 7 algorithm (1978).
  • constructVernerRobust7() - Verner's "most robust" order 7 algorithm.
  • constructTanakaYamashitaStable7() - Tanaka-Yamashita more stable order 7 algorithm.
  • constructTanakaYamashitaEfficient7() - Tanaka-Yamashita more efficient order 7 algorithm.
  • constructSharpSmart7() - Sharp-Smart's order 7 algorithm.
  • constructSharpVerner7() - Sharp-Verner's order 7 algorithm.
  • constructVerner7() - Verner's "most efficient" order 7 algorithm.
  • constructVernerEfficient7() - Verner's "most efficient" order 7 algorithm.
  • constructClassicVerner8() - A classic Verner order 8 algorithm (1978).
  • constructCooperVerner8() - Cooper-Verner's first order 8 algorithm.
  • constructCooperVerner82() - Cooper-Verner's second order 8 algorithm.
  • constructTsitourasPapakostas8() - Tsitouras-Papakostas order 8 algorithm.
  • constructdverk78() - The classic order 8 DVERK algorithm.
  • constructEnrightVerner8() - Enright-Verner order 8 algorithm.
  • constructCurtis8() - Curtis' order 8 algorithm.
  • constructVerner8() - Verner's "most efficient" order 8 algorithm.
  • constructRKF8() - Runge-Kutta-Fehlberg Order 7/8 method.
  • constructDormandPrice8() - Dormand-Prince Order 7/8 method.
  • constructDormandPrince8_64bit() - Dormand-Prince Order 7/8 method. Coefficients are rational approximations good for 64 bits.
  • constructVernerRobust9() - Verner's "most robust" order 9 method.
  • constructVernerEfficient9() - Verner's "most efficient" order 9 method.
  • constructSharp9() - Sharp's order 9 method.
  • constructTsitouras9() - Tsitouras's first order 9 method.
  • constructTsitouras92() - Tsitouras's second order 9 method.
  • constructCurtis10() - Curtis' order 10 method.
  • constructOno10() - Ono's order 10 method.
  • constructFeagin10Tableau() - Feagin's order 10 method.
  • constructCurtis10() - Curtis' order 10 method.
  • constructBaker10() - Baker's order 10 method.
  • constructHairer10() Hairer's order 10 method.
  • constructFeagin12Tableau() - Feagin's order 12 method.
  • constructOno12() - Ono's order 12 method.
  • constructFeagin14Tableau() Feagin's order 14 method.

Implicit Runge-Kutta Methods

  • constructImplicitEuler - The 1st order Implicit Euler method.
  • constructMidpointRule - The 2nd order Midpoint method.
  • constructTrapezoidalRule - The 2nd order Trapezoidal rule (2nd order LobattoIIIA)
  • constructLobattoIIIA4 - The 4th order LobattoIIIA
  • constructLobattoIIIB2 - The 2nd order LobattoIIIB
  • constructLobattoIIIB4 - The 4th order LobattoIIIB
  • constructLobattoIIIC2 - The 2nd order LobattoIIIC
  • constructLobattoIIIC4 - The 4th order LobattoIIIC
  • constructLobattoIIICStar2 - The 2nd order LobattoIIIC*
  • constructLobattoIIICStar4 - The 4th order LobattoIIIC*
  • constructLobattoIIID2 - The 2nd order LobattoIIID
  • constructLobattoIIID4 - The 4th order LobattoIIID
  • constructRadauIA3 - The 3rd order RadauIA
  • constructRadauIA5 - The 5th order RadauIA
  • constructRadauIIA3 - The 3rd order RadauIIA
  • constructRadauIIA5 - The 5th order RadauIIA

Tableau Methods

DiffEqDevTools.stability_region — Function

stability_region(z, tab::ODERKTableau; embedded = false)

Calculates the stability function from the tableau at z. Stable if <1. If embedded = true, the stability function is calculated for the embedded method. Otherwise, the stability function is calculated for the main method (default).

\[r(z) = 1 + z bᵀ(I - zA)⁻¹ e\]

where e denotes a vector of ones.

source
stability_region(z, alg::AbstractODEAlgorithm)

Calculates the stability function from the algorithm alg at z. The stability region of a possible embedded method cannot be calculated using this method.

If you use an implicit method, you may run into convergence issues when the value of z is outside of the stability region or when |z| is so large that the true stability-function value is below floatmin (subnormal). On hardware or BLAS configurations with flush-to-zero (FTZ) enabled, subnormal Newton corrections are flushed to zero, causing the solve to fail and return the initial value rather than the correct near-zero result. Use inputs where 1/|z| is a normal floating-point number to avoid this.

julia> stability_region(typemin(Float64), ImplicitEuler())
┌ Warning: Newton steps could not converge and algorithm is not adaptive. Use a lower dt.

julia> abs(stability_region(-1.0e16, ImplicitEuler())) < eps(Float64)
true
source

stability_region(tab_or_alg::Union{ODERKTableau, AbstractODEAlgorithm}; initial_guess=-3.0)

Calculates the length of the stability region in the real axis. See also imaginary_stability_interval.

source
DiffEqDevTools.imaginary_stability_interval — Function
imaginary_stability_interval(
    tab::ODERKTableau;
    initial_guess = length(tab) - 1
)

Calculates the length of the imaginary stability interval, i.e., the size of the stability region on the imaginary axis. See also stability_region.

source
imaginary_stability_interval(alg::ODERKTableau; initial_guess = 20.0)

Calculates the length of the imaginary stability interval, i.e., the size of the stability region on the imaginary axis. See also stability_region.

source
DiffEqDevTools.check_tableau — Function
check_tableau(tab; tol = 10eps(1.0))

Check that a Runge-Kutta tableau satisfies the order conditions for its declared primary and embedded orders within tol. Return true when all conditions hold and throw an error when an order condition fails.

source

Explicit Tableaus

<!– Historical constructor names are retained in the prose list above; they are not current exported or public bindings. DiffEqDevTools.constructEuler DiffEqDevTools.constructRalston DiffEqDevTools.constructHeun DiffEqDevTools.constructKutta3 OrdinaryDiffEq.constructBS3 DiffEqDevTools.constructBogakiShampine3 DiffEqDevTools.constructRK4 DiffEqDevTools.constructRK438Rule DiffEqDevTools.constructRKF4 DiffEqDevTools.constructRKF5 DiffEqDevTools.constructCashKarp DiffEqDevTools.constructDormandPrince OrdinaryDiffEq.constructBS5 DiffEqDevTools.constructPapakostasPapaGeorgiou5 DiffEqDevTools.constructPapakostasPapaGeorgiou52 DiffEqDevTools.constructTsitouras5 DiffEqDevTools.constructLutherKonen5 DiffEqDevTools.constructLutherKonen52 DiffEqDevTools.constructLutherKonen53 DiffEqDevTools.constructRungeFirst5 DiffEqDevTools.constructLawson5 DiffEqDevTools.constructSharpSmart5 DiffEqDevTools.constructBogakiShampine5 DiffEqDevTools.constructCassity5 DiffEqDevTools.constructButcher6 DiffEqDevTools.constructButcher62 DiffEqDevTools.constructButcher63 DiffEqDevTools.constructVernerRobust6 DiffEqDevTools.constructTanakaKasugaYamashitaYazaki6A DiffEqDevTools.constructTanakaKasugaYamashitaYazaki6B DiffEqDevTools.constructTanakaKasugaYamashitaYazaki6C DiffEqDevTools.constructTanakaKasugaYamashitaYazaki6D DiffEqDevTools.constructHuta6 DiffEqDevTools.constructHuta62 DiffEqDevTools.constructVerner6 DiffEqDevTools.constructDormandPrince6 DiffEqDevTools.constructSharpVerner6 DiffEqDevTools.constructVern6 DiffEqDevTools.constructClassicVerner6 DiffEqDevTools.constructChummund6 DiffEqDevTools.constructChummund62 DiffEqDevTools.constructPapakostas6 DiffEqDevTools.constructLawson6 DiffEqDevTools.constructTsitourasPapakostas6 DiffEqDevTools.constructDormandLockyerMcCorriganPrince6 DiffEqDevTools.constructVernerEfficient6 DiffEqDevTools.constructMikkawyEisa DiffEqDevTools.constructVernerEfficient7 DiffEqDevTools.constructClassicVerner7 DiffEqDevTools.constructSharpVerner7 DiffEqDevTools.constructTanakaYamashitaStable7 DiffEqDevTools.constructSharpSmart7 DiffEqDevTools.constructTanakaYamashitaEfficient7 DiffEqDevTools.constructVernerRobust7 OrdinaryDiffEq.constructTanYam7 DiffEqDevTools.constructEnrightVerner7 DiffEqDevTools.constructDormandPrince8 DiffEqDevTools.constructRKF8 DiffEqDevTools.constructCooperVerner8 DiffEqDevTools.constructCooperVerner82 DiffEqDevTools.constructTsitourasPapakostas8 DiffEqDevTools.constructEnrightVerner8 DiffEqDevTools.constructdverk78 DiffEqDevTools.constructClassicVerner8 DiffEqDevTools.constructDormandPrince8_64bit DiffEqDevTools.constructCurtis8 OrdinaryDiffEq.constructTsitPap8 DiffEqDevTools.constructSharp9 DiffEqDevTools.constructTsitouras9 DiffEqDevTools.constructTsitouras92 DiffEqDevTools.constructVernerEfficient9 OrdinaryDiffEq.constructVern9 DiffEqDevTools.constructVerner916 DiffEqDevTools.constructVerner9162 DiffEqDevTools.constructVernerRobust9 DiffEqDevTools.constructFeagin10 DiffEqDevTools.constructFeagin10Tableau DiffEqDevTools.constructOno10 DiffEqDevTools.constructCurtis10 DiffEqDevTools.constructHairer10 DiffEqDevTools.constructBaker10 DiffEqDevTools.constructFeagin12 DiffEqDevTools.constructOno12 DiffEqDevTools.constructFeagin12Tableau DiffEqDevTools.constructFeagin14 –>

Implicit Tableaus

<!– The current implicit solver constructors are documented on their corresponding algorithm pages. DiffEqDevTools.constructImplicitEuler DiffEqDevTools.constructMidpointRule DiffEqDevTools.constructTrapezoidalRule DiffEqDevTools.constructLobattoIIIA4 DiffEqDevTools.constructLobattoIIIB2 DiffEqDevTools.constructLobattoIIIB4 DiffEqDevTools.constructLobattoIIIC2 DiffEqDevTools.constructLobattoIIIC4 DiffEqDevTools.constructLobattoIIICStar2 DiffEqDevTools.constructLobattoIIICStar4 DiffEqDevTools.constructLobattoIIID2 DiffEqDevTools.constructLobattoIIID4 DiffEqDevTools.constructGL2 DiffEqDevTools.constructGL4 DiffEqDevTools.constructGL6 DiffEqDevTools.constructRadauIA3 DiffEqDevTools.constructRadauIA5 DiffEqDevTools.constructRadauIIA3 –>

Rosenbrock tableaus

These coefficient-tableau types are developer API for OrdinaryDiffEq solver implementations. Application code should select the corresponding documented Rosenbrock algorithm instead.

OrdinaryDiffEqRosenbrockTableaus.ROS2PRRodasTableau — Function
ROS2PRRodasTableau(T, T2)

A 2nd order stiffly accurate Rosenbrock method with 3 stages and Rinf = 0. Reference: Rang, J. (2014). The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods.

source
OrdinaryDiffEqRosenbrockTableaus.ROS3PRodasTableau — Function
ROS3PRodasTableau(T, T2)

A 3rd order A-stable Rosenbrock method with 3 stages, designed for parabolic problems. Reference: Lang, J., & Verwer, J. (2001). ROS3P - An accurate third-order Rosenbrock solver designed for parabolic problems.

source
OrdinaryDiffEqRosenbrockTableaus.Rodas3PRodasTableau — Function
Rodas3PRodasTableau(T, T2)

A 3rd order Rosenbrock method with 5 stages, including a dense output matrix H. Reference: Steinebach, G. (2024). Rosenbrock methods within OrdinaryDiffEq.jl - Overview, recent developments and applications. Proceedings of the JuliaCon Conferences.

source
OrdinaryDiffEqRosenbrockTableaus.Rodas3RodasTableau — Function
Rodas3RodasTableau(T, T2)

A 3rd order Rosenbrock method with 4 stages. Reference: Sandu, A., et al. (1997). Benchmarking stiff ode solvers for atmospheric chemistry problems-I. implicit vs explicit. Atmospheric Environment, 31(19), 3151-3166.

source
OrdinaryDiffEqRosenbrockTableaus.Rodas3dRodasTableau — Function
Rodas3dRodasTableau(T, T2)

A 3rd order stiffly accurate Rosenbrock method with 4 stages and an embedded 2nd order method for adaptivity. Constructed with the damping parameter γ = 0.57281606 so that R(±∞) = 0, which damps both stable and unstable modes. Designed for steady-state focused DAE integration such as the semi-implicit continuous Newton method, where damping speed matters more than trajectory accuracy. Reference: Yu, R., Gu, W., Xu, Y., Lu, S. (2024). Semi-implicit Continuous Newton Method for Power Flow Analysis. arXiv:2312.02809. Coefficients: https://github.com/rzyu45/MATPOWER-SICNM (coeff_rodas3d.m).

source
OrdinaryDiffEqRosenbrockTableaus.Rodas42Tableau — Function
Rodas42Tableau(T, T2)

A 4th order L-stable Rosenbrock method with 6 stages, often used as an alternative to Rodas4. Reference: Hairer, E., & Wanner, G. (1996). Solving Ordinary Differential Equations II: Stiff and Differential-Algebraic Problems. Springer-Verlag, 2nd Edition.

source
OrdinaryDiffEqRosenbrockTableaus.Rodas4P2Tableau — Function
Rodas4P2Tableau(T, T2)

An improved version of the Rodas4P 4th order L-stable Rosenbrock method. Reference: Steinebach, G. (2020). Improvement of Rosenbrock-Wanner method RODASP. In: Progress in Differential-Algebraic Equations II, pp. 165–184. Springer, Cham.

source
OrdinaryDiffEqRosenbrockTableaus.Rodas4PTableau — Function
Rodas4PTableau(T, T2)

A 4th order L-stable Rosenbrock method with 6 stages, emphasizing stability for parabolic problems. Reference: Steinebach, G. (1995). Order-reduction of ROW-methods for DAEs and method of lines applications. Preprint-Nr. 1741, FB Mathematik, TH Darmstadt.

source
OrdinaryDiffEqRosenbrockTableaus.Rodas4PWTableau — Function
Rodas4PWTableau(T, T2)

An adaptation of Rodas4P 4th order L-stable Rosenbrock method into a W-method. Reference: Steinebach, G. (2026). Fourth order Rosenbrock W method for stiff Odes and DAEs. In: in preparation.

source
OrdinaryDiffEqRosenbrockTableaus.Rodas4Tableau — Function
Rodas4Tableau(T, T2)

The tableau for the 4th order L-stable Rosenbrock method Rodas4. It is a 6-stage method with a built-in error estimate. Reference: Hairer, E., Nørsett, S. P., & Wanner, G. (1996). Solving Ordinary Differential Equations II.

source
OrdinaryDiffEqRosenbrockTableaus.Rodas5Tableau — Function
Rodas5Tableau(T, T2)

The tableau for the 5th order stiffly accurate Rosenbrock method Rodas5. It is an 8-stage method with a built-in error estimate. Reference: Di Marzo, G. (1993). RODAS5(4) - Méthodes de Rosenbrock d'ordre 5(4) adaptées aux problèmes différentiels-algébriques.

source
OrdinaryDiffEqRosenbrockTableaus.RodasTableau — Type
RodasTableau

Coefficient tableau for Rosenbrock methods: the stage coefficient matrices A and C, the diagonal coefficient gamma, the abscissae c, the time-derivative coefficients d, the dense-output interpolation matrix H (empty for methods without stiff-aware interpolation), the solution weights b, and the embedded error-estimate weights btilde (a vector for adaptive methods, nothing for fixed-step methods).

source