Runge Kutta Library Functions

Tableau of a Partitioned Runge-Kutta method

\[\begin{aligned} Q_{n,i} &= q_{n} + h \sum \limits_{j=1}^{s} a_{ij} \, v(t_{n} + c_j \Delta t, Q_{n,j}, P_{n,j}) , & q_{n+1} &= q_{n} + h \sum \limits_{i=1}^{s} b_{i} \, v(t_{n} + c_j \Delta t, Q_{n,i}, P_{n,i}) , \\ P_{n,i} &= p_{n} + h \sum \limits_{i=1}^{s} \bar{a}_{ij} \, f(t_{n} + c_j \Delta t, Q_{n,j}, P_{n,j}) , & p_{n+1} &= p_{n} + h \sum \limits_{i=1}^{s} \bar{b}_{i} \, f(t_{n} + c_j \Delta t, Q_{n,i}, P_{n,i}) . \end{aligned}\]

Parameters:

• T: datatype of coefficient arrays

Fields:

• name: symbolic name of the tableau
• o: order of the method
• s: number of stages
• q: Tableau for q
• p: Tableau for p
• R∞: stability function at infinity

The actual tableaus are stored in q and p:

• a: coefficients $a_{ij}$ with $ 1 \le i,j \le s$
• b: weights $b_{i}$ with $ 1 \le i \le s$
• c: nodes $c_{i}$ with $ 1 \le i \le s$

Constructors:

PartitionedTableau{T}(name, o, q, p)
PartitionedTableau{T}(name, q, p)
PartitionedTableau(name::Symbol, q::Tableau, p::Tableau)
PartitionedTableau(name::Symbol, q::Tableau)

Holds the tableau of a Runge-Kutta method

\[\begin{aligned} Q_{n,i} &= q_{n} + h \sum \limits_{j=1}^{s} a_{ij} \, v(t_{n} + c_j \Delta t, Q_{n,j}) , & q_{n+1} &= q_{n} + h \sum \limits_{i=1}^{s} b_{i} \, v(t_{n} + c_j \Delta t, Q_{n,i}) , \\ \end{aligned}\]

Parameters:

• T: datatype of coefficient arrays

Fields:

• name: symbolic name of the tableau
• o: order of the method
• s: number of stages
• a: coefficients $a_{ij}$ with $ 1 \le i,j \le s$
• b: weights $b_{i}$ with $ 1 \le i \le s$
• c: nodes $c_{i}$ with $ 1 \le i \le s$
• R∞: stability function at infinity

Constructors:

Tableau{T}(name, o, s, a, b, c)
Tableau{T}(name, o, a, b, c)
Tableau(name::Symbol, o::Int, s::Int, a::AbstractMatrix, b::AbstractVector, c::AbstractVector)
Tableau(name::Symbol, o::Int, a::AbstractMatrix, b::AbstractVector, c::AbstractVector)
Tableau(name::Symbol, o::Int, t::AbstractMatrix)

The last constructor accepts an $(s+1) \times (s+1)$ array that holds the whole tableau in the form of a Butcher tableau, i.e.,

Base.show(io::IO, ::MIME"text/markdown", tab::Tableau)

Generate and print a nice markdown table for the Runge-Kutta tableau.

Base.show(io::IO, tab::PartitionedTableau)

Pretty-print Partitioned Runge-Kutta tableau.

Base.show(io::IO, tab::Tableau)

Pretty-print Runge-Kutta tableau.

SymplecticConjugateTableau(tab::Tableau)

Generates a new tableau with symplectic conjugate coefficients.

SymplecticPartitionedTableau(tab::Tableau)

Generates a partitioned tableau with tab and ist symplectic adjoint.

SymplecticTableau(tab::Tableau)

Generates a new tableau with symplectizied coefficients.

Legendre polynomial P_s(x) of degree s defined on the interval [-1..+1].

Legendre polynomial of degree s shifted to the interval [0..1], i.e., P_s(2x-1).

from_file(dir::AbstractString, name::AbstractString)

Read Runge-Kutta tableau from the file <name>.tsv in the directory dir.

Compute the weights by solving the simplifying assumption $B(s)$:

\[\sum \limits_{j=1}^{s} b_{j} c_{j}^{k-1} = \frac{1}{k} \qquad k = 1 , \, ... , \, s .\]

Compute the coefficients by solving the simplifying assumption $C(s)$:

\[\sum \limits_{j=1}^{s} a_{ij} c_{j}^{k-1} = \frac{c_i^k}{k} \qquad i = 1 , \, ... , \, s , \; k = 1 , \, ... , \, s .\]

Compute the coefficients by solving the simplifying assumption $D(s)$:

\[\sum \limits_{i=1}^{s} b_i c_{i}^{k-1} a_{ij} = \frac{b_j}{k} ( 1 - c_j^k) \qquad j = 1 , \, ... , \, s , \; k = 1 , \, ... , \, s .\]

to_file(dir::AbstractString, tab::Tableau)

Write Runge-Kutta tableau to the file <tab.name>.tsv in the directory dir.

Alias for TableauImplicitEuler

Tableau of Crank-Nicolson two-stage, 2nd order method

TableauCrankNicolson(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

J. Crank and P. Nicolson.
A practical method for numerical evaluation of solutions of partial differential equations of the heat-conduction type.
Mathematical Proceedings of the Cambridge Philosophical Society, Volume 43, Issue 1, Pages 50-67, 1947.
doi: 10.1017/S0305004100023197

Tableau of Crouzeix's two-stage, 3rd order method

TableauCrouzeix(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

M.Crouzeix.
Sur L'approximation des équations différentielles opérationelles linéaires par des méthodes de Runge-Kutta.
Thesis. Université de Paris, 1975.

Tableau of one-stage, 1st order explicit (forward) Euler method

TableauExplicitEuler(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Leonhard Euler.
Institutiones calculi differentialis cum eius vsu in analysi finitorum ac doctrina serierum.
Imp. Acad. Imper. Scient. Petropolitanae, Opera Omnia, Vol.X, [I.6], 1755.
In: Opera Omnia, 1st Series, Volume 11, Institutiones Calculi Integralis. Teubner, Leipzig, Pages 424-434, 1913.
Sectio secunda. Caput VII. De integratione aequationum differentialium per approximationem. Problema 85.

Tableau of explicit two-stage, 2nd order midpoint method

TableauExplicitMidpoint(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Carl Runge.
Über die numerische Auflösung von Differentialgleichungen.
Mathematische Annalen, Volume 46, Pages 167-178, 1895.
doi: 10.1007/BF01446807.
Equation (2)

Alias for TableauExplicitEuler

Gauss tableau with s stages

TableauGauss(::Type{T}, s)
TableauGauss(s) = TableauGauss(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

References:

John C. Butcher.
Implicit Runge-Kutta processes.
Mathematics of Computation, Volume 18, Pages 50-64, 1964.
doi: 10.1090/S0025-5718-1964-0159424-9.

John C. Butcher.
Gauss Methods. 
In: Engquist B. (eds). Encyclopedia of Applied and Computational Mathematics. Springer, Berlin, Heidelberg. 2015.
doi: 10.1007/978-3-540-70529-1_115.

Tableau of Heun's two-stage, 2nd order method

TableauHeun2(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Karl Heun.
Neue Methoden zur approximativen Integration der Differentialgleichungen einer unabhängigen Veränderlichen.
Zeitschrift für Mathematik und Physik, Volume 45, Pages 23-38, 1900.
Algorithm II.

Tableau of Heun's three-stage, 3rd order method

TableauHeun3(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Karl Heun.
Neue Methoden zur approximativen Integration der Differentialgleichungen einer unabhängigen Veränderlichen.
Zeitschrift für Mathematik und Physik, Volume 45, Pages 23-38, 1900.
Algorithm VI.

Tableau of one-stage, 1st order implicit (backward) Euler method

TableauImplicitEuler(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Augustin-Louis Cauchy.
Équations différentielles ordinaires. Cours inédit (fragment). Douzième leçon.
Ed. Christian Gilain, Etudes Vivantes, 1981.
Page 102, Equation (5), Θ=1.

Tableau of two-stage, 2nd order implicit midpoint method

TableauImplicitMidpoint(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Augustin-Louis Cauchy.
Équations différentielles ordinaires. Cours inédit (fragment). Douzième leçon.
Ed. Christian Gilain, Etudes Vivantes, 1981.
Page 102, Equation (5), Θ=1/2.

Tableau of Kraaijevanger and Spijker's two-stage, 2nd order method

TableauKraaijevangerSpijker(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

J. F. B. M. Kraaijevanger and M. N. Spijker.
Algebraic stability and error propagation in Runge-Kutta methods.
Applied Numerical Mathematics, Volume 5, Issues 1-2, Pages 71-87, 1989.
doi: 10.1016/0168-9274(89)90025-1

Tableau of Kutta's three-stage, 3rd order method

TableauKutta(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Wilhelm Kutta
Beitrag zur Näherungsweisen Integration totaler Differentialgleichungen
Zeitschrift für Mathematik und Physik, Volume 46, Pages 435-453, 1901.
Page 440

Alias for TableauKutta

Lobatto III tableau with s stages

TableauLobattoIII(::Type{T}, s)
TableauLobattoIII(s) = TableauLobattoIII(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

Sometimes this tableau is also referred to as Lobatto IIIC*.

References:

John C. Butcher.
Integration processes based on Radau quadrature formulas
Mathematics of Computation, Volume 18, Pages 233-244, 1964.
doi: 10.1090/S0025-5718-1964-0165693-1.

Laurent O. Jay.
Lobatto Methods.
In: Engquist B. (eds). Encyclopedia of Applied and Computational Mathematics. Springer, Berlin, Heidelberg. 2015.
doi: 10.1007/978-3-540-70529-1_123.

Lobatto IIIA tableau with s stages

TableauLobattoIIIA(::Type{T}, s)
TableauLobattoIIIA(s) = TableauLobattoIIIA(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

References:

Byron Leonard Ehle
On Padé approximations to the exponential function and a-stable methods for the numerical solution of initial value problems.
Research Report CSRR 2010, Dept. AACS, University of Waterloo, 1969.

Laurent O. Jay.
Lobatto Methods.
In: Engquist B. (eds). Encyclopedia of Applied and Computational Mathematics. Springer, Berlin, Heidelberg. 2015.
doi: 10.1007/978-3-540-70529-1_123

Lobatto IIIB tableau with s stages

TableauLobattoIIIB(::Type{T}, s)
TableauLobattoIIIB(s) = TableauLobattoIIIB(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

References:

Byron Leonard Ehle.
On Padé approximations to the exponential function and a-stable methods for the numerical solution of initial value problems.
Research Report CSRR 2010, Dept. AACS, University of Waterloo, 1969.

Laurent O. Jay.
Lobatto Methods.
In: Engquist B. (eds). Encyclopedia of Applied and Computational Mathematics. Springer, Berlin, Heidelberg. 2015.
doi: 10.1007/978-3-540-70529-1_123.

Lobatto IIIB̄ tableau with s stages

TableauLobattoIIIB̄(::Type{T}, s)
TableauLobattoIIIB̄(s) = TableauLobattoIIIB̄(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

Lobatto IIIB̄ tableau is the conjugate symplectic to TableauLobattoIIIB. On paper, its coefficients are identical to TableauLobattoIIIA, however, they are computed by the symplecticity condition and not by the formula for Lobatto IIIA and thus the numerical values are slightly different.

Lobatto IIIC tableau with s stages

TableauLobattoIIIC(::Type{T}, s)
TableauLobattoIIIC(s) = TableauLobattoIIIC(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

References:

F. H. Chipman.
A-stable Runge-Kutta processes.
BIT, Volume 11, Pages 384-388, 1971.
doi: 10.1007/BF01939406.

Laurent O. Jay.
Lobatto Methods.
In: Engquist B. (eds). Encyclopedia of Applied and Computational Mathematics. Springer, Berlin, Heidelberg. 2015.
doi: 10.1007/978-3-540-70529-1_123.

Lobatto IIIC̄ tableau with s stages

TableauLobattoIIIC̄(::Type{T}, s)
TableauLobattoIIIC̄(s) = TableauLobattoIIIC̄(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

Lobatto IIIC̄ tableau is the conjugate symplectic to TableauLobattoIIIC. On paper, its coefficients are identical to TableauLobattoIII, however, they are computed by the symplecticity condition and not by the formula for Lobatto III and thus the numerical values are slightly different.

Lobatto IIID tableau with s stages

TableauLobattoIIID(::Type{T}, s)
TableauLobattoIIID(s) = TableauLobattoIIID(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

References:

R.P.K. Chan.
On symmetric Runge-Kutta methods of high order.
Computing, Volume 45, Pages 301-309, 1990.
doi: 10.1007/BF02238798

Laurent O. Jay.
Lobatto Methods.
In: Engquist B. (eds). Encyclopedia of Applied and Computational Mathematics. Springer, Berlin, Heidelberg. 2015.
doi: 10.1007/978-3-540-70529-1_123.

Lobatto IIID̄ tableau with s stages

TableauLobattoIIID̄(::Type{T}, s)
TableauLobattoIIID̄(s) = TableauLobattoIIID̄(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

Lobatto IIID̄ tableau is the conjugate symplectic to TableauLobattoIIID. On paper, the coefficients of the Lobatto IIID tableau are symplectic, however, the Lobatto IIID̄ coefficients are computed by the symplecticity condition and not by the formula for Lobatto IIID and thus the numerical values are slightly different.

Lobatto IIIE tableau with s stages

TableauLobattoIIIE(::Type{T}, s)
TableauLobattoIIIE(s) = TableauLobattoIIIE(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

References:

R.P.K. Chan.
On symmetric Runge-Kutta methods of high order.
Computing, Volume 45, Pages 301-309, 1990.
doi: 10.1007/BF02238798

Laurent O. Jay.
Lobatto Methods.
In: Engquist B. (eds). Encyclopedia of Applied and Computational Mathematics. Springer, Berlin, Heidelberg. 2015.
doi: 10.1007/978-3-540-70529-1_123.

Lobatto IIIF tableau with s stages

TableauLobattoIIIF(::Type{T}, s)
TableauLobattoIIIF(s) = TableauLobattoIIIF(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

References:

Wang Fangzong and Liao Xiaobing.
A Class of Lobatto Methods of Order 2s.
Journal of Applied Mathematics, Volume 46, Pages 6-10, 2016.

Lobatto IIIF̄ tableau with s stages

TableauLobattoIIIF̄(::Type{T}, s)
TableauLobattoIIIF̄(s) = TableauLobattoIIIF̄(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

The Lobatto IIIF̄ tableau is the conjugate symplectic to TableauLobattoIIIF.

Lobatto IIIG tableau with s stages

TableauLobattoIIIG(::Type{T}, s)
TableauLobattoIIIG(s) = TableauLobattoIIIG(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

Symplectizied algorithm for TableauLobattoIIIF

Coefficients are taken as $a^G = \frac{1}{2} ( a^F + \bar{a}^F )$ where the coefficients $\bar{a}^F$ are computed such that the symplecticity conditions $b_{i} \bar{a}_{i,j} + \bar{b}_{j} a_{j,i} = b_{i} \bar{b}_{j}$ and $b_{i} = \bar{b}_i$ hold for all $1 \le i,j \le s$.

Lobatto IIIĀ tableau with s stages

TableauLobattoIIIĀ(::Type{T}, s)
TableauLobattoIIIĀ(s) = TableauLobattoIIIĀ(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

Lobatto IIIĀ tableau is the conjugate symplectic to TableauLobattoIIIA. On paper, its coefficients are identical to TableauLobattoIIIB, however, they are computed by the symplecticity condition and not by the formula for Lobatto IIIB and thus the numerical values are slightly different.

Lobatto IIIĒ tableau with s stages

TableauLobattoIIIĒ(::Type{T}, s)
TableauLobattoIIIĒ(s) = TableauLobattoIIIĒ(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

Lobatto IIIĒ tableau is the conjugate symplectic to TableauLobattoIIIE. On paper, the coefficients of the Lobatto IIIE tableau are symplectic, however, the Lobatto IIIĒ coefficients are computed by the symplecticity condition and not by the formula for Lobatto IIIE and thus the numerical values are slightly different.

Lobatto IIIḠ tableau with s stages

TableauLobattoIIIḠ(::Type{T}, s)
TableauLobattoIIIḠ(s) = TableauLobattoIIIḠ(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

Lobatto IIIḠ tableau is the conjugate symplectic to TableauLobattoIIIG. On paper, the coefficients of the Lobatto IIIG tableau are symplectic, however, the Lobatto IIIḠ coefficients are computed by the symplecticity condition and not by the formula for Lobatto IIIG and thus the numerical values are slightly different.

Tableau of Qin and Zhang's symplectic two-stage, 2nd order method

TableauQinZhang(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

M.-Z. Qin and M.-Q. Zhang.
Symplectic Runge-Kutta algorithms for Hamilton systems.
Journal of Computational Mathematics, Supplementary Issue, Pages 205-215, 1992.

Alias for TableauHeun2 according to

John C. Butcher
Numerical Methods for Ordinary Differential Equations. Wiley, 2016.
Page 99

Alias for TableauRunge according to

John C. Butcher
Numerical Methods for Ordinary Differential Equations. Wiley, 2016.
Page 99

Tableau of a three-stage, 3rd order method

TableauKutta(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

John C. Butcher
Numerical Methods for Ordinary Differential Equations. Wiley, 2016.
Page 99

Alias for TableauKutta according to

John C. Butcher
Numerical Methods for Ordinary Differential Equations. Wiley, 2016.
Page 99

Alias for TableauRK416

Alias for TableauRK416 according to

John C. Butcher
Numerical Methods for Ordinary Differential Equations. Wiley, 2016.
Page 102

Tableau of explicit Runge-Kutta method of order four (1/6 rule)

TableauRK416(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Wilhelm Kutta
Beitrag zur Näherungsweisen Integration totaler Differentialgleichungen
Zeitschrift für Mathematik und Physik, Volume 46, Pages 435-453, 1901.
Page 443

Tableau of explicit Runge-Kutta method of order four with four stages

TableauRK42(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

John C. Butcher
Numerical Methods for Ordinary Differential Equations. Wiley, 2016.
Page 102

Tableau of explicit Runge-Kutta method of order four (3/8 rule)

TableauRK438(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Wilhelm Kutta
Beitrag zur Näherungsweisen Integration totaler Differentialgleichungen
Zeitschrift für Mathematik und Physik, Volume 46, Pages 435-453, 1901.
Page 441

Tableau of explicit Runge-Kutta method of order five with six stages

TableauRK5(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

John C. Butcher
Numerical Methods for Ordinary Differential Equations. Wiley, 2016.
Page 103

Radau IA tableau with s stages

TableauRadauIA(::Type{T}, s)
TableauRadauIA(s) = TableauRadauIA(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

References:

Byron Leonard Ehle
On Padé approximations to the exponential function and a-stable methods for the numerical solution of initial value problems.
Research Report CSRR 2010, Dept. AACS, University of Waterloo, 1969.

Radau IB tableau with s stages

TableauRadauIB(::Type{T}, s)
TableauRadauIB(s) = TableauRadauIB(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

Coefficients are taken as $a^B = \frac{1}{2} ( a^A + \bar{a}^A )$ where $a^A$ are the coefficients of the Radau IA method and $\bar{a}^A$ are computed such that the symplecticity conditions $b_{i} \bar{a}_{i,j} + \bar{b}_{j} a_{j,i} = b_{i} \bar{b}_{j}$ and $b_{i} = \bar{b}_i$ hold for all $1 \le i,j \le s$.

Reference:

Sun Geng
Construction of high order symplectic Runge-Kutta methods
Journal of Computational Mathematics, Volume 11, Pages 250-260, 1993.

Radau IIA tableau with s stages

TableauRadauIIA(::Type{T}, s)
TableauRadauIIA(s) = TableauRadauIIA(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

References:

Byron Leonard Ehle
On Padé approximations to the exponential function and a-stable methods for the numerical solution of initial value problems.
Research Report CSRR 2010, Dept. AACS, University of Waterloo, 1969.

Owe Axelsson.
A class of A-stable methods.
BIT, Volume 9, Pages 185-199, 1969.
doi: 10.1007/BF01946812.

Ernst Hairer and Gerhard Wanner.
Radau Methods.
In: Engquist B. (eds). Encyclopedia of Applied and Computational Mathematics. Springer, Berlin, Heidelberg. 2015.
doi: 10.1007/978-3-540-70529-1_139.

Radau IIB tableau with s stages

TableauRadauIIB(::Type{T}, s)
TableauRadauIIB(s) = TableauRadauIIB(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

Coefficients are taken as $a^B = \frac{1}{2} ( a^A + \bar{a}^A )$ where $a^A$ are the coefficients of the Radau IIA method and $\bar{a}^AV are computed such that the symplecticity conditions$b{i} \bar{a}{i,j} + \bar{b}{j} a{j,i} = b{i} \bar{b}{j}$and$b{i} = \bar{b}i$hold for all$1 \le i,j \le s``.

Reference:

Sun Geng
Construction of high order symplectic Runge-Kutta methods
Journal of Computational Mathematics, Volume 11, Pages 250-260, 1993.

Tableau of Ralston's two-stage, 2nd order method

TableauRalston2(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Anthony Ralston.
Runge-Kutta Methods with Minimum Error Bounds.
Mathematics of Computation, Volume 16, Pages 431-437, 1962.
doi: 10.1090/S0025-5718-1962-0150954-0.
Equation (3.5)

Tableau of Ralston's three-stage, 3rd order method

TableauRalston3(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Anthony Ralston.
Runge-Kutta Methods with Minimum Error Bounds.
Mathematics of Computation, Volume 16, Pages 431-437, 1962.
doi: 10.1090/S0025-5718-1962-0150954-0.
Equation (4.10)

Tableau of Runge's two-stage, 2nd order method

TableauRunge(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Carl Runge
Über die numerische Auflösung von Differentialgleichungen.
Mathematische Annalen, Volume 46, Pages 167-178, 1895.
doi: 10.1007/BF01446807.
Equation (3)

Alias for TableauRunge

Tableau of symmetric and symplectic three-stage, 4th order Runge-Kutta method

TableauSRK3(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Shan Zhao and Guo-Wei Wei.
A unified discontinuous Galerkin framework for time integration.
Mathematical Methods in the Applied Sciences, Volume 37, Issue 7, Pages 1042-1071, 2014.
doi: 10.1002/mma.2863.

Tableau of 2rd order Strong Stability Preserving method with two stages and CFL ≤ 1

TableauSSPRK2(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

This is the same tableau as TableauHeun2.

Reference:

Chi-Wang Shu, Stanley Osher.
Efficient implementation of essentially non-oscillatory shock-capturing schemes.
Journal of Computational Physics, Volume 77, Issue 2, Pages 439-471, 1988.
doi: 10.1016/0021-9991(88)90177-5.
Equation (2.16)

Tableau of 3rd order Strong Stability Preserving method with three stages and CFL ≤ 1

TableauSSPRK3(::Type{T}=Float64) where {T}

The constructor takes one optional argument, that is the element type of the tableau.

Reference:

Chi-Wang Shu, Stanley Osher.
Efficient implementation of essentially non-oscillatory shock-capturing schemes.
Journal of Computational Physics, Volume 77, Issue 2, Pages 439-471, 1988.
doi: 10.1016/0021-9991(88)90177-5.
Equation (2.18)

The Gauss coefficients are implicitly given by the so-called simplifying assumption $C(s)$:

\[\sum \limits_{j=1}^{s} a_{ij} c_{j}^{k-1} = \frac{c_i^k}{k} \qquad i = 1 , \, ... , \, s , \; k = 1 , \, ... , \, s .\]

The Gauss nodes are given by the roots of the shifted Legendre polynomial $P_s (2x-1)$ with $s$ the number of stages.

The Gauss weights are given by the following integrals

\[b_i = \bigg( \frac{dP}{dx} (c_i) \bigg)^{-2} \int \limits_0^1 \bigg( \frac{P(x)}{x - c_i} \bigg)^2 dx ,\]

where $P(x)$ denotes the shifted Legendre polynomial $P(x) = P_s (2x-1)$ with $s$ the number of stages.

The Lobatto IIIA coefficients are implicitly given by the so-called simplifying assumption $C(s)$:

\[\sum \limits_{j=1}^{s} a_{ij} c_{j}^{k-1} = \frac{c_i^k}{k} \qquad i = 1 , \, ... , \, s , \; k = 1 , \, ... , \, s .\]

The Lobatto IIIB coefficients are implicitly given by the so-called simplifying assumption $D(s)$:

\[\sum \limits_{i=1}^{s} b_i c_{i}^{k-1} a_{ij} = \frac{b_j}{k} ( 1 - c_j^k) \qquad j = 1 , \, ... , \, s , \; k = 1 , \, ... , \, s .\]

The Lobatto IIIC coefficients are determined by setting $a_{i,1} = b_1$ and solving the so-called simplifying assumption $C(s-1)$, given by

\[\sum \limits_{j=1}^{s} a_{ij} c_{j}^{k-1} = \frac{c_i^k}{k} \qquad i = 1 , \, ... , \, s , \; k = 1 , \, ... , \, s-1 ,\]

for $a_{i,j}$ with $i = 1, ..., s$ and $j = 2, ..., s$.

The Lobatto IIIC̄ coefficients are determined by setting $a_{i,s} = 0$ and solving the so-called simplifying assumption $C(s-1)$, given by

\[\sum \limits_{j=1}^{s} a_{ij} c_{j}^{k-1} = \frac{c_i^k}{k} \qquad i = 1 , \, ... , \, s , \; k = 1 , \, ... , \, s-1 ,\]

for $a_{i,j}$ with $i = 1, ..., s$ and $j = 1, ..., s-1$.

The s-stage Lobatto nodes are defined as the roots of the following polynomial of degree $s$:

\[\frac{d^{s-2}}{dx^{s-2}} \big( (x - x^2)^{s-1} \big) .\]

get_lobatto_nullvector(::Type, s; normalize=false)
get_lobatto_nullvector(s; kwargs...)

Computes the nullvector of the matrix containing the derivatives of the Lagrange basis on the s Lobatto nodes evaluated on these nodes.

The Lobatto weights can be explicitly computed by the formula

\[b_j = \frac{1}{s (s-1) P_{s-1}(2 c_j - 1)^2} \qquad j = 1 , \, ... , \, s ,\]

where $P_k$ is the $k$th Legendre polynomial, given by

\[P_k (x) = \frac{1}{k! 2^k} \big( \frac{d^k}{dx^k} (x^2 - 1)^k \big) .\]

The Radau IA coefficients are implicitly given by the so-called simplifying assumption $D(s)$:

\[\sum \limits_{i=1}^{s} b_i c_{i}^{k-1} a_{ij} = \frac{b_j}{k} ( 1 - c_j^k) \qquad j = 1 , \, ... , \, s , \; k = 1 , \, ... , \, s .\]

The s-stage Radau IA nodes are defined as the roots of the following polynomial of degree $s$:

\[\frac{d^{s-1}}{dx^{s-1}} \big( x^s (x - 1)^{s-1} \big) .\]

The Radau IA weights are implicitly given by the so-called simplifying assumption $B(s)$:

\[\sum \limits_{j=1}^{s} b_{j} c_{j}^{k-1} = \frac{1}{k} \qquad k = 1 , \, ... , \, s .\]

The Radau IIA coefficients are implicitly given by the so-called simplifying assumption $C(s)$:

\[\sum \limits_{j=1}^{s} a_{ij} c_{j}^{k-1} = \frac{c_i^k}{k} \qquad i = 1 , \, ... , \, s , \; k = 1 , \, ... , \, s .\]

The s-stage Radau IIA nodes are defined as the roots of the following polynomial of degree $s$:

\[\frac{d^{s-1}}{dx^{s-1}} \big( x^{s-1} (x - 1)^s \big) .\]

The Radau IIA weights are implicitly given by the so-called simplifying assumption $B(s)$:

\[\sum \limits_{j=1}^{s} b_{j} c_{j}^{k-1} = \frac{1}{k} \qquad k = 1 , \, ... , \, s .\]

Partitioned Gauss-Legendre Runge-Kutta tableau with s stages

PartitionedTableauGauss(::Type{T}, s)
PartitionedTableauGauss(s) = PartitionedTableauGauss(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauGauss for both coefficients a and ā.

Partitioned Gauss-Lobatto IIIA-IIIB tableau with s stages

TableauLobattoIIIAIIIB(::Type{T}, s)
TableauLobattoIIIAIIIB(s) = TableauLobattoIIIAIIIB(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIIA for a and TableauLobattoIIIB for ā.

Tableau for Gauss-Lobatto IIIA-IIIĀ method with s stages

TableauLobattoIIIAIIIĀ(::Type{T}, s)
TableauLobattoIIIAIIIĀ(s) = TableauLobattoIIIAIIIĀ(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIIA for a and TableauLobattoIIIĀ for ā.

Tableau for Gauss-Lobatto IIIB-IIIA method with s stages

TableauLobattoIIIBIIIA(::Type{T}, s)
TableauLobattoIIIBIIIA(s) = TableauLobattoIIIBIIIA(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIIB for a and TableauLobattoIIIA for ā.

Tableau for Gauss-Lobatto IIIB-IIIB̄ method with s stages

TableauLobattoIIIBIIIB̄(::Type{T}, s)
TableauLobattoIIIBIIIB̄(s) = TableauLobattoIIIBIIIB̄(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIIB for a and TableauLobattoIIIB̄ for ā.

Tableau for Gauss-Lobatto IIIC-IIIC̄ method with s stages

TableauLobattoIIICIIIC̄(::Type{T}, s)
TableauLobattoIIICIIIC̄(s) = TableauLobattoIIICIIIC̄(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIIC for a and TableauLobattoIIIC̄ for ā.

Tableau for Gauss-Lobatto IIIC̄-IIIC method with s stages

TableauLobattoIIIC̄IIIC(::Type{T}, s)
TableauLobattoIIIC̄IIIC(s) = TableauLobattoIIIC̄IIIC(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIIC̄ for a and TableauLobattoIIIC for ā.

Tableau for Gauss-Lobatto IIID-IIID̄ method with s stages

TableauLobattoIIIDIIID̄(::Type{T}, s)
TableauLobattoIIIDIIID̄(s) = TableauLobattoIIIDIIID̄(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIID for a and TableauLobattoIIID̄ for ā.

Tableau for Gauss-Lobatto IIIE-IIIĒ method with s stages

TableauLobattoIIIEIIIĒ(::Type{T}, s)
TableauLobattoIIIEIIIĒ(s) = TableauLobattoIIIEIIIĒ(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIIE for a and TableauLobattoIIIĒ for ā.

Tableau for Gauss-Lobatto IIIF-IIIF̄ method with s stages

TableauLobattoIIIFIIIF̄(::Type{T}, s)
TableauLobattoIIIFIIIF̄(s) = TableauLobattoIIIFIIIF̄(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIIF for a and TableauLobattoIIIF̄ for ā.

Tableau for Gauss-Lobatto IIIF̄-IIIF method with s stages

TableauLobattoIIIF̄IIIF(::Type{T}, s)
TableauLobattoIIIF̄IIIF(s) = TableauLobattoIIIF̄IIIF(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIIF̄ for a and TableauLobattoIIIF for ā.

Tableau for Gauss-Lobatto IIIG-IIIḠ method with s stages

TableauLobattoIIIGIIIḠ(::Type{T}, s)
TableauLobattoIIIGIIIḠ(s) = TableauLobattoIIIGIIIḠ(Float64, s)

The constructor takes the number of stages s and optionally the element type T of the tableau.

This PartitionedTableau uses TableauLobattoIIIG for a and TableauLobattoIIIḠ for ā.