BoundaryValueDiffEq.jl

Shooting(ode_alg; kwargs...)
Shooting(ode_alg, nlsolve; kwargs...)
Shooting(; ode_alg = nothing, nlsolve = nothing, optimize = nothing, jac_alg = nothing) -> Shooting

Configures the single-shooting algorithm for a boundary value problem. Single shooting integrates one initial value problem and solves for the initial condition that satisfies the boundary conditions.

Arguments

• ode_alg: algorithm used to solve the internal SciMLBase.ODEProblem. Pass this as the first positional argument or keyword argument. nothing selects a loaded polyalgorithm; otherwise an ODE algorithm must be supplied.
• nlsolve: nonlinear-solver algorithm for the shooting residual. Its autodiff setting is superseded by jac_alg when a Jacobian algorithm is materialized.

Keywords

• ode_alg = nothing: ODE algorithm, as described above.
• nlsolve = nothing: nonlinear-solver algorithm, as described above.
• optimize = nothing: optimization-solver algorithm used when the selected BVP solve path formulates the residual as an optimization problem.
• jac_alg = nothing: BVPJacobianAlgorithm configuration. When omitted, the constructor derives it from nlsolve and the problem during solve initialization. For single shooting, only its diffmode setting is used; the default is AutoForwardDiff when applicable and otherwise AutoFiniteDiff.

Fields

• ode_alg: configured ODE algorithm or nothing.
• nlsolve: configured nonlinear-solver algorithm or nothing.
• optimize: configured optimization-solver algorithm or nothing.
• jac_alg::BVPJacobianAlgorithm: materialized Jacobian-algorithm configuration.

Returns

• Shooting: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqShooting: Shooting
using OrdinaryDiffEqTsit5: Tsit5

alg = Shooting(Tsit5())
@assert alg isa Shooting
# output

MultipleShooting(;
        nshoots::Int, ode_alg = nothing, nlsolve = nothing,
        optimize = nothing, grid_coarsening = true, jac_alg = nothing
    ) -> MultipleShooting
MultipleShooting(nshoots::Int; kwargs...)
MultipleShooting(nshoots::Int, ode_alg; kwargs...)
MultipleShooting(nshoots::Int, ode_alg, nlsolve; kwargs...)

Configures the multiple-shooting algorithm for a boundary value problem. Multiple shooting integrates an IVP on nshoots subintervals and solves for their matching initial conditions; it is generally more stable than Shooting.

Arguments

• nshoots::Int: number of shooting subintervals.
• ode_alg: algorithm used to solve each internal SciMLBase.ODEProblem. Pass this as the second positional argument or keyword argument. nothing selects a loaded polyalgorithm; otherwise an ODE algorithm must be supplied.
• nlsolve: nonlinear-solver algorithm for the multiple-shooting residual.

Keywords

• ode_alg = nothing: ODE algorithm, as described above.

• nlsolve = nothing: nonlinear-solver algorithm, as described above.

• optimize = nothing: optimization-solver algorithm used when the selected BVP solve path formulates the residual as an optimization problem.

• jac_alg = nothing: BVPJacobianAlgorithm configuration. When omitted, the constructor derives it from nlsolve and the problem during solve initialization.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode we default to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff()). For bc_diffmode, we default to AutoForwardDiff if possible else AutoFiniteDiff.

• grid_coarsening = true: coarsens the multiple-shooting grid while generating a stable IVP solution. Supported values are:

  • true: Halve the grid size, till we reach a grid size of 1.
  • false: Do not coarsen the grid. Solve a Multiple Shooting Problem and finally solve a Single Shooting Problem.
  • AbstractVector{<:Int} or Ntuple{N, <:Integer}: Use the provided grid coarsening. For example, if nshoots = 10 and grid_coarsening = [5, 2], then the grid will be coarsened to [5, 2]. Note that 1 should not be present in the grid coarsening.
  • Function: Takes the current number of shooting points and returns the next number of shooting points. For example, if nshoots = 10 and grid_coarsening = n -> n ÷ 2, then the grid will be coarsened to [5, 2].

Fields

• ode_alg: configured ODE algorithm or nothing.
• nlsolve: configured nonlinear-solver algorithm or nothing.
• optimize: configured optimization-solver algorithm or nothing.
• jac_alg::BVPJacobianAlgorithm: materialized Jacobian-algorithm configuration.
• nshoots::Int: configured number of shooting subintervals.
• grid_coarsening: configured grid-coarsening strategy.

Returns

• MultipleShooting: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqShooting: MultipleShooting
using OrdinaryDiffEqTsit5: Tsit5

alg = MultipleShooting(8, Tsit5(); grid_coarsening = true)
@assert alg isa MultipleShooting
# output

MIRK2(; nlsolve = NewtonRaphson(), jac_alg = BVPJacobianAlgorithm(),
        defect_threshold = 0.1, max_num_subintervals = 3000)

2th order Monotonic Implicit Runge Kutta method.

Keyword Arguments

• nlsolve: Internal Nonlinear solver. Any solver which conforms to the SciML NonlinearProblem interface can be used. Note that any autodiff argument for the solver will be ignored and a custom jacobian algorithm will be used.

• optimize: Internal Optimization solver. Any solver which conforms to the SciML OptimizationProblem interface can be used. Note that any autodiff argument for the solver will be ignored and a custom jacobian algorithm will be used. Optimization solvers should first be loaded to allow this functionality.

• jac_alg: Jacobian Algorithm used for the nonlinear solver. Defaults to BVPJacobianAlgorithm(), which automatically decides the best algorithm to use based on the input types and problem type.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff()). For bc_diffmode, defaults to AutoForwardDiff if possible else AutoFiniteDiff.

• defect_threshold: Threshold for defect control.

• max_num_subintervals: Number of maximal subintervals, default as 3000.

References

@article{Enright1996RungeKuttaSW,
    title={Runge-Kutta Software with Defect Control for Boundary Value ODEs},
    author={Wayne H. Enright and Paul H. Muir},
    journal={SIAM J. Sci. Comput.},
    year={1996},
    volume={17},
    pages={479-497}
}

MIRK3(; nlsolve = NewtonRaphson(), jac_alg = BVPJacobianAlgorithm(),
        defect_threshold = 0.1, max_num_subintervals = 3000)

3th order Monotonic Implicit Runge Kutta method.

Keyword Arguments

• nlsolve: Internal Nonlinear solver. Any solver which conforms to the SciML NonlinearProblem interface can be used. Note that any autodiff argument for the solver will be ignored and a custom jacobian algorithm will be used.

• optimize: Internal Optimization solver. Any solver which conforms to the SciML OptimizationProblem interface can be used. Note that any autodiff argument for the solver will be ignored and a custom jacobian algorithm will be used. Optimization solvers should first be loaded to allow this functionality.

• jac_alg: Jacobian Algorithm used for the nonlinear solver. Defaults to BVPJacobianAlgorithm(), which automatically decides the best algorithm to use based on the input types and problem type.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff()). For bc_diffmode, defaults to AutoForwardDiff if possible else AutoFiniteDiff.

• defect_threshold: Threshold for defect control.

• max_num_subintervals: Number of maximal subintervals, default as 3000.

References

@article{Enright1996RungeKuttaSW,
    title={Runge-Kutta Software with Defect Control for Boundary Value ODEs},
    author={Wayne H. Enright and Paul H. Muir},
    journal={SIAM J. Sci. Comput.},
    year={1996},
    volume={17},
    pages={479-497}
}

MIRK4(; nlsolve = NewtonRaphson(), jac_alg = BVPJacobianAlgorithm(),
        defect_threshold = 0.1, max_num_subintervals = 3000)

4th order Monotonic Implicit Runge Kutta method.

Keyword Arguments

• nlsolve: Internal Nonlinear solver. Any solver which conforms to the SciML NonlinearProblem interface can be used. Note that any autodiff argument for the solver will be ignored and a custom jacobian algorithm will be used.

• optimize: Internal Optimization solver. Any solver which conforms to the SciML OptimizationProblem interface can be used. Note that any autodiff argument for the solver will be ignored and a custom jacobian algorithm will be used. Optimization solvers should first be loaded to allow this functionality.

• jac_alg: Jacobian Algorithm used for the nonlinear solver. Defaults to BVPJacobianAlgorithm(), which automatically decides the best algorithm to use based on the input types and problem type.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff()). For bc_diffmode, defaults to AutoForwardDiff if possible else AutoFiniteDiff.

• defect_threshold: Threshold for defect control.

• max_num_subintervals: Number of maximal subintervals, default as 3000.

References

@article{Enright1996RungeKuttaSW,
    title={Runge-Kutta Software with Defect Control for Boundary Value ODEs},
    author={Wayne H. Enright and Paul H. Muir},
    journal={SIAM J. Sci. Comput.},
    year={1996},
    volume={17},
    pages={479-497}
}

MIRK5(; nlsolve = NewtonRaphson(), jac_alg = BVPJacobianAlgorithm(),
        defect_threshold = 0.1, max_num_subintervals = 3000)

5th order Monotonic Implicit Runge Kutta method.

Keyword Arguments

• nlsolve: Internal Nonlinear solver. Any solver which conforms to the SciML NonlinearProblem interface can be used. Note that any autodiff argument for the solver will be ignored and a custom jacobian algorithm will be used.

• optimize: Internal Optimization solver. Any solver which conforms to the SciML OptimizationProblem interface can be used. Note that any autodiff argument for the solver will be ignored and a custom jacobian algorithm will be used. Optimization solvers should first be loaded to allow this functionality.

• jac_alg: Jacobian Algorithm used for the nonlinear solver. Defaults to BVPJacobianAlgorithm(), which automatically decides the best algorithm to use based on the input types and problem type.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff()). For bc_diffmode, defaults to AutoForwardDiff if possible else AutoFiniteDiff.

• defect_threshold: Threshold for defect control.

• max_num_subintervals: Number of maximal subintervals, default as 3000.

References

@article{Enright1996RungeKuttaSW,
    title={Runge-Kutta Software with Defect Control for Boundary Value ODEs},
    author={Wayne H. Enright and Paul H. Muir},
    journal={SIAM J. Sci. Comput.},
    year={1996},
    volume={17},
    pages={479-497}
}

MIRK6(; nlsolve = NewtonRaphson(), jac_alg = BVPJacobianAlgorithm(),
        defect_threshold = 0.1, max_num_subintervals = 3000)

6th order Monotonic Implicit Runge Kutta method.

Keyword Arguments

• nlsolve: Internal Nonlinear solver. Any solver which conforms to the SciML NonlinearProblem interface can be used. Note that any autodiff argument for the solver will be ignored and a custom jacobian algorithm will be used.

• optimize: Internal Optimization solver. Any solver which conforms to the SciML OptimizationProblem interface can be used. Note that any autodiff argument for the solver will be ignored and a custom jacobian algorithm will be used. Optimization solvers should first be loaded to allow this functionality.

• jac_alg: Jacobian Algorithm used for the nonlinear solver. Defaults to BVPJacobianAlgorithm(), which automatically decides the best algorithm to use based on the input types and problem type.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff()). For bc_diffmode, defaults to AutoForwardDiff if possible else AutoFiniteDiff.

• defect_threshold: Threshold for defect control.

• max_num_subintervals: Number of maximal subintervals, default as 3000.

References

@article{Enright1996RungeKuttaSW,
    title={Runge-Kutta Software with Defect Control for Boundary Value ODEs},
    author={Wayne H. Enright and Paul H. Muir},
    journal={SIAM J. Sci. Comput.},
    year={1996},
    volume={17},
    pages={479-497}
}

LobattoIIIa2(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIa2

Configures the 2-stage Lobatto IIIA fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIa2: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIa2

alg = LobattoIIIa2()
@assert alg isa LobattoIIIa2
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIa3(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIa3

Configures the 3-stage Lobatto IIIA fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIa3: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIa3

alg = LobattoIIIa3()
@assert alg isa LobattoIIIa3
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIa4(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIa4

Configures the 4-stage Lobatto IIIA fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIa4: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIa4

alg = LobattoIIIa4()
@assert alg isa LobattoIIIa4
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIa5(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIa5

Configures the 5-stage Lobatto IIIA fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIa5: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIa5

alg = LobattoIIIa5()
@assert alg isa LobattoIIIa5
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIb2(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIb2

Configures the 2-stage Lobatto IIIB fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIb2: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIb2

alg = LobattoIIIb2()
@assert alg isa LobattoIIIb2
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIb3(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIb3

Configures the 3-stage Lobatto IIIB fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIb3: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIb3

alg = LobattoIIIb3()
@assert alg isa LobattoIIIb3
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIb4(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIb4

Configures the 4-stage Lobatto IIIB fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIb4: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIb4

alg = LobattoIIIb4()
@assert alg isa LobattoIIIb4
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIb5(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIb5

Configures the 5-stage Lobatto IIIB fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIb5: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIb5

alg = LobattoIIIb5()
@assert alg isa LobattoIIIb5
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIc2(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIc2

Configures the 2-stage Lobatto IIIC fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIc2: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIc2

alg = LobattoIIIc2()
@assert alg isa LobattoIIIc2
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIc3(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIc3

Configures the 3-stage Lobatto IIIC fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIc3: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIc3

alg = LobattoIIIc3()
@assert alg isa LobattoIIIc3
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIc4(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIc4

Configures the 4-stage Lobatto IIIC fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIc4: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIc4

alg = LobattoIIIc4()
@assert alg isa LobattoIIIc4
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

LobattoIIIc5(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> LobattoIIIc5

Configures the 5-stage Lobatto IIIC fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• LobattoIIIc5: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: LobattoIIIc5

alg = LobattoIIIc5()
@assert alg isa LobattoIIIc5
# output

References

Reference for Lobatto and Radau methods:

@Inbook{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    editor="Engquist, Bj{"o}rn",
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

RadauIIa1(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> RadauIIa1

Configures the 1-stage Radau IIA fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• RadauIIa1: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: RadauIIa1

alg = RadauIIa1()
@assert alg isa RadauIIa1
# output

References

Reference for Lobatto and Radau methods:

@incollection{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    editor={Engquist, Bj{"o}rn},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

RadauIIa2(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> RadauIIa2

Configures the 2-stage Radau IIA fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• RadauIIa2: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: RadauIIa2

alg = RadauIIa2()
@assert alg isa RadauIIa2
# output

References

Reference for Lobatto and Radau methods:

@incollection{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    editor={Engquist, Bj{"o}rn},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

RadauIIa3(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> RadauIIa3

Configures the 3-stage Radau IIA fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• RadauIIa3: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: RadauIIa3

alg = RadauIIa3()
@assert alg isa RadauIIa3
# output

References

Reference for Lobatto and Radau methods:

@incollection{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    editor={Engquist, Bj{"o}rn},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

RadauIIa5(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> RadauIIa5

Configures the 5-stage Radau IIA fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• RadauIIa5: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: RadauIIa5

alg = RadauIIa5()
@assert alg isa RadauIIa5
# output

References

Reference for Lobatto and Radau methods:

@incollection{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    editor={Engquist, Bj{"o}rn},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

RadauIIa7(; nlsolve = nothing, optimize = nothing,
    jac_alg = BVPJacobianAlgorithm(), nested_nlsolve = false,
    nested_nlsolve_kwargs = (;), defect_threshold = 0.1,
    max_num_subintervals = 3000) -> RadauIIa7

Configures the 7-stage Radau IIA fully implicit Runge-Kutta method.

Keywords

• nlsolve = nothing: nonlinear solver for the collocation residual. The BVP Jacobian configuration takes precedence over an autodiff setting on this solver.

• optimize = nothing: optimization solver used when the selected BVP path formulates the residual as an optimization problem.

• jac_alg = BVPJacobianAlgorithm(): differentiation strategy for the boundary and collocation residuals.

  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode, the default is AutoSparse(AutoForwardDiff()) if possible, otherwise AutoSparse(AutoFiniteDiff()). For bc_diffmode, the default is AutoForwardDiff() if possible, otherwise AutoFiniteDiff().

• nested_nlsolve = false: solve each implicit Runge-Kutta step with a nested nonlinear solve instead of including its stages in the global residual.

• nested_nlsolve_kwargs = (;): keyword arguments forwarded to the nested nonlinear solver.

• defect_threshold = 0.1: defect threshold used by mesh adaptivity.

• max_num_subintervals = 3000: maximum number of mesh subintervals.

Fields

• nlsolve: configured nonlinear solver or nothing.
• optimize: configured optimization solver or nothing.
• jac_alg::BVPJacobianAlgorithm: Jacobian configuration.
• nested_nlsolve::Bool: whether nested nonlinear solves are enabled.
• nested_nlsolve_kwargs::NamedTuple: options for the nested nonlinear solver.
• defect_threshold: adaptive defect threshold.
• max_num_subintervals::Int: mesh-size limit.

Returns

• RadauIIa7: an algorithm object accepted by SciMLBase.solve for a boundary value problem.

Examples

using BoundaryValueDiffEqFIRK: RadauIIa7

alg = RadauIIa7()
@assert alg isa RadauIIa7
# output

References

Reference for Lobatto and Radau methods:

@incollection{Jay2015,
    author="Jay, Laurent O.",
    editor="Engquist, Bj{"o}rn",
    title="Lobatto Methods",
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    year="2015",
    publisher="Springer Berlin Heidelberg",
}
@incollection{engquist_radau_2015,
    author = {Hairer, Ernst and Wanner, Gerhard},
    editor={Engquist, Bj{"o}rn},
    title = {Radau {Methods}},
    booktitle = {Encyclopedia of {Applied} and {Computational} {Mathematics}},
    publisher = {Springer Berlin Heidelberg},
    year = {2015},
}

References for implementation of defect control, based on the bvp5c solver in MATLAB:

@article{shampine_solving_nodate,
    title = {Solving {Boundary} {Value} {Problems} for {Ordinary} {Differential} {Equations} in {Matlab} with bvp4c},
    author = {Shampine, Lawrence F and Kierzenka, Jacek and Reichelt, Mark W},
    year = {2000},
}

@article{kierzenka_bvp_2008,
    title = {A {BVP} {Solver} that {Controls} {Residual} and {Error}},
    author = {Kierzenka, J and Shampine, L F},
    year = {2008},
}

@article{russell_adaptive_1978,
    title = {Adaptive {Mesh} {Selection} {Strategies} for {Solving} {Boundary} {Value} {Problems}},
    journal = {SIAM Journal on Numerical Analysis},
    author = {Russell, R. D. and Christiansen, J.},
    year = {1978},
}

Ascher1(; nlsolve = nothing, optimize = nothing, zeta = Float64[],
    jac_alg = BVPJacobianAlgorithm(), max_num_subintervals = 3000)

1-stage Gauss-Legendre collocation method with Ascher error-control adaptivity and mesh refinement for boundary-value problems, including problems with algebraic constraints.

Fields

• nlsolve: Nonlinear solver used for the collocation system. nothing selects the package default.
• optimize: Optimization solver used by the mesh-refinement machinery. nothing selects the package default.
• zeta: Side-condition locations for problems that require them. The default empty vector is appropriate when no side conditions are present.
• jac_alg: BVPJacobianAlgorithm that selects the Jacobian construction strategy for the collocation system.
• max_num_subintervals: Maximum number of mesh subintervals permitted while refining the solution.

Keyword Arguments

• nlsolve = nothing: Internal nonlinear solver. Any solver implementing the SciML NonlinearProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• optimize = nothing: Internal optimization solver. Any solver implementing the SciML OptimizationProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• zeta = Float64[]: Side-condition locations. Supply the points required by the problem; leave empty when the problem has no side conditions.
• jac_alg = BVPJacobianAlgorithm(): Jacobian construction strategy. For type stability, provide ForwardDiff chunk sizes in the AD types selected by this value.
• max_num_subintervals = 3000: Maximum number of mesh subintervals.

Example

alg = Ascher1(zeta = [0.0, 0.5, 1.0])

References

@article{Ascher1994CollocationSF,
    title={Collocation Software for Boundary Value Differential-Algebraic Equations},
    author={Uri M. Ascher and Raymond J. Spiteri},
    journal={SIAM J. Sci. Comput.},
    year={1994},
    volume={15},
    pages={938-952},
    url={https://api.semanticscholar.org/CorpusID:10597070}
}

@article{Ascher1979ACS,
    title={A collocation solver for mixed order systems of boundary value problems},
    author={Uri M. Ascher and J. Christiansen and Robert D. Russell},
    journal={Mathematics of Computation},
    year={1979},
    volume={33},
    pages={659-679},
    url={https://api.semanticscholar.org/CorpusID:121729124}
}

Ascher2(; nlsolve = nothing, optimize = nothing, zeta = Float64[],
    jac_alg = BVPJacobianAlgorithm(), max_num_subintervals = 3000)

2-stage Gauss-Legendre collocation method with Ascher error-control adaptivity and mesh refinement for boundary-value problems, including problems with algebraic constraints.

Fields

• nlsolve: Nonlinear solver used for the collocation system. nothing selects the package default.
• optimize: Optimization solver used by the mesh-refinement machinery. nothing selects the package default.
• zeta: Side-condition locations for problems that require them. The default empty vector is appropriate when no side conditions are present.
• jac_alg: BVPJacobianAlgorithm that selects the Jacobian construction strategy for the collocation system.
• max_num_subintervals: Maximum number of mesh subintervals permitted while refining the solution.

Keyword Arguments

• nlsolve = nothing: Internal nonlinear solver. Any solver implementing the SciML NonlinearProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• optimize = nothing: Internal optimization solver. Any solver implementing the SciML OptimizationProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• zeta = Float64[]: Side-condition locations. Supply the points required by the problem; leave empty when the problem has no side conditions.
• jac_alg = BVPJacobianAlgorithm(): Jacobian construction strategy. For type stability, provide ForwardDiff chunk sizes in the AD types selected by this value.
• max_num_subintervals = 3000: Maximum number of mesh subintervals.

Example

alg = Ascher2(zeta = [0.0, 0.5, 1.0])

References

@article{Ascher1994CollocationSF,
    title={Collocation Software for Boundary Value Differential-Algebraic Equations},
    author={Uri M. Ascher and Raymond J. Spiteri},
    journal={SIAM J. Sci. Comput.},
    year={1994},
    volume={15},
    pages={938-952},
    url={https://api.semanticscholar.org/CorpusID:10597070}
}

@article{Ascher1979ACS,
    title={A collocation solver for mixed order systems of boundary value problems},
    author={Uri M. Ascher and J. Christiansen and Robert D. Russell},
    journal={Mathematics of Computation},
    year={1979},
    volume={33},
    pages={659-679},
    url={https://api.semanticscholar.org/CorpusID:121729124}
}

Ascher3(; nlsolve = nothing, optimize = nothing, zeta = Float64[],
    jac_alg = BVPJacobianAlgorithm(), max_num_subintervals = 3000)

3-stage Gauss-Legendre collocation method with Ascher error-control adaptivity and mesh refinement for boundary-value problems, including problems with algebraic constraints.

Fields

• nlsolve: Nonlinear solver used for the collocation system. nothing selects the package default.
• optimize: Optimization solver used by the mesh-refinement machinery. nothing selects the package default.
• zeta: Side-condition locations for problems that require them. The default empty vector is appropriate when no side conditions are present.
• jac_alg: BVPJacobianAlgorithm that selects the Jacobian construction strategy for the collocation system.
• max_num_subintervals: Maximum number of mesh subintervals permitted while refining the solution.

Keyword Arguments

• nlsolve = nothing: Internal nonlinear solver. Any solver implementing the SciML NonlinearProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• optimize = nothing: Internal optimization solver. Any solver implementing the SciML OptimizationProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• zeta = Float64[]: Side-condition locations. Supply the points required by the problem; leave empty when the problem has no side conditions.
• jac_alg = BVPJacobianAlgorithm(): Jacobian construction strategy. For type stability, provide ForwardDiff chunk sizes in the AD types selected by this value.
• max_num_subintervals = 3000: Maximum number of mesh subintervals.

Example

alg = Ascher3(zeta = [0.0, 0.5, 1.0])

References

@article{Ascher1994CollocationSF,
    title={Collocation Software for Boundary Value Differential-Algebraic Equations},
    author={Uri M. Ascher and Raymond J. Spiteri},
    journal={SIAM J. Sci. Comput.},
    year={1994},
    volume={15},
    pages={938-952},
    url={https://api.semanticscholar.org/CorpusID:10597070}
}

@article{Ascher1979ACS,
    title={A collocation solver for mixed order systems of boundary value problems},
    author={Uri M. Ascher and J. Christiansen and Robert D. Russell},
    journal={Mathematics of Computation},
    year={1979},
    volume={33},
    pages={659-679},
    url={https://api.semanticscholar.org/CorpusID:121729124}
}

Ascher4(; nlsolve = nothing, optimize = nothing, zeta = Float64[],
    jac_alg = BVPJacobianAlgorithm(), max_num_subintervals = 3000)

4-stage Gauss-Legendre collocation method with Ascher error-control adaptivity and mesh refinement for boundary-value problems, including problems with algebraic constraints.

Fields

• nlsolve: Nonlinear solver used for the collocation system. nothing selects the package default.
• optimize: Optimization solver used by the mesh-refinement machinery. nothing selects the package default.
• zeta: Side-condition locations for problems that require them. The default empty vector is appropriate when no side conditions are present.
• jac_alg: BVPJacobianAlgorithm that selects the Jacobian construction strategy for the collocation system.
• max_num_subintervals: Maximum number of mesh subintervals permitted while refining the solution.

Keyword Arguments

• nlsolve = nothing: Internal nonlinear solver. Any solver implementing the SciML NonlinearProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• optimize = nothing: Internal optimization solver. Any solver implementing the SciML OptimizationProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• zeta = Float64[]: Side-condition locations. Supply the points required by the problem; leave empty when the problem has no side conditions.
• jac_alg = BVPJacobianAlgorithm(): Jacobian construction strategy. For type stability, provide ForwardDiff chunk sizes in the AD types selected by this value.
• max_num_subintervals = 3000: Maximum number of mesh subintervals.

Example

alg = Ascher4(zeta = [0.0, 0.5, 1.0])

References

@article{Ascher1994CollocationSF,
    title={Collocation Software for Boundary Value Differential-Algebraic Equations},
    author={Uri M. Ascher and Raymond J. Spiteri},
    journal={SIAM J. Sci. Comput.},
    year={1994},
    volume={15},
    pages={938-952},
    url={https://api.semanticscholar.org/CorpusID:10597070}
}

@article{Ascher1979ACS,
    title={A collocation solver for mixed order systems of boundary value problems},
    author={Uri M. Ascher and J. Christiansen and Robert D. Russell},
    journal={Mathematics of Computation},
    year={1979},
    volume={33},
    pages={659-679},
    url={https://api.semanticscholar.org/CorpusID:121729124}
}

Ascher5(; nlsolve = nothing, optimize = nothing, zeta = Float64[],
    jac_alg = BVPJacobianAlgorithm(), max_num_subintervals = 3000)

5-stage Gauss-Legendre collocation method with Ascher error-control adaptivity and mesh refinement for boundary-value problems, including problems with algebraic constraints.

Fields

• nlsolve: Nonlinear solver used for the collocation system. nothing selects the package default.
• optimize: Optimization solver used by the mesh-refinement machinery. nothing selects the package default.
• zeta: Side-condition locations for problems that require them. The default empty vector is appropriate when no side conditions are present.
• jac_alg: BVPJacobianAlgorithm that selects the Jacobian construction strategy for the collocation system.
• max_num_subintervals: Maximum number of mesh subintervals permitted while refining the solution.

Keyword Arguments

• nlsolve = nothing: Internal nonlinear solver. Any solver implementing the SciML NonlinearProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• optimize = nothing: Internal optimization solver. Any solver implementing the SciML OptimizationProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• zeta = Float64[]: Side-condition locations. Supply the points required by the problem; leave empty when the problem has no side conditions.
• jac_alg = BVPJacobianAlgorithm(): Jacobian construction strategy. For type stability, provide ForwardDiff chunk sizes in the AD types selected by this value.
• max_num_subintervals = 3000: Maximum number of mesh subintervals.

Example

alg = Ascher5(zeta = [0.0, 0.5, 1.0])

References

@article{Ascher1994CollocationSF,
    title={Collocation Software for Boundary Value Differential-Algebraic Equations},
    author={Uri M. Ascher and Raymond J. Spiteri},
    journal={SIAM J. Sci. Comput.},
    year={1994},
    volume={15},
    pages={938-952},
    url={https://api.semanticscholar.org/CorpusID:10597070}
}

@article{Ascher1979ACS,
    title={A collocation solver for mixed order systems of boundary value problems},
    author={Uri M. Ascher and J. Christiansen and Robert D. Russell},
    journal={Mathematics of Computation},
    year={1979},
    volume={33},
    pages={659-679},
    url={https://api.semanticscholar.org/CorpusID:121729124}
}

Ascher6(; nlsolve = nothing, optimize = nothing, zeta = Float64[],
    jac_alg = BVPJacobianAlgorithm(), max_num_subintervals = 3000)

6-stage Gauss-Legendre collocation method with Ascher error-control adaptivity and mesh refinement for boundary-value problems, including problems with algebraic constraints.

Fields

• nlsolve: Nonlinear solver used for the collocation system. nothing selects the package default.
• optimize: Optimization solver used by the mesh-refinement machinery. nothing selects the package default.
• zeta: Side-condition locations for problems that require them. The default empty vector is appropriate when no side conditions are present.
• jac_alg: BVPJacobianAlgorithm that selects the Jacobian construction strategy for the collocation system.
• max_num_subintervals: Maximum number of mesh subintervals permitted while refining the solution.

Keyword Arguments

• nlsolve = nothing: Internal nonlinear solver. Any solver implementing the SciML NonlinearProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• optimize = nothing: Internal optimization solver. Any solver implementing the SciML OptimizationProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• zeta = Float64[]: Side-condition locations. Supply the points required by the problem; leave empty when the problem has no side conditions.
• jac_alg = BVPJacobianAlgorithm(): Jacobian construction strategy. For type stability, provide ForwardDiff chunk sizes in the AD types selected by this value.
• max_num_subintervals = 3000: Maximum number of mesh subintervals.

Example

alg = Ascher6(zeta = [0.0, 0.5, 1.0])

References

@article{Ascher1994CollocationSF,
    title={Collocation Software for Boundary Value Differential-Algebraic Equations},
    author={Uri M. Ascher and Raymond J. Spiteri},
    journal={SIAM J. Sci. Comput.},
    year={1994},
    volume={15},
    pages={938-952},
    url={https://api.semanticscholar.org/CorpusID:10597070}
}

@article{Ascher1979ACS,
    title={A collocation solver for mixed order systems of boundary value problems},
    author={Uri M. Ascher and J. Christiansen and Robert D. Russell},
    journal={Mathematics of Computation},
    year={1979},
    volume={33},
    pages={659-679},
    url={https://api.semanticscholar.org/CorpusID:121729124}
}

Ascher7(; nlsolve = nothing, optimize = nothing, zeta = Float64[],
    jac_alg = BVPJacobianAlgorithm(), max_num_subintervals = 3000)

7-stage Gauss-Legendre collocation method with Ascher error-control adaptivity and mesh refinement for boundary-value problems, including problems with algebraic constraints.

Fields

• nlsolve: Nonlinear solver used for the collocation system. nothing selects the package default.
• optimize: Optimization solver used by the mesh-refinement machinery. nothing selects the package default.
• zeta: Side-condition locations for problems that require them. The default empty vector is appropriate when no side conditions are present.
• jac_alg: BVPJacobianAlgorithm that selects the Jacobian construction strategy for the collocation system.
• max_num_subintervals: Maximum number of mesh subintervals permitted while refining the solution.

Keyword Arguments

• nlsolve = nothing: Internal nonlinear solver. Any solver implementing the SciML NonlinearProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• optimize = nothing: Internal optimization solver. Any solver implementing the SciML OptimizationProblem interface may be used. Its autodifferentiation setting is ignored because this solver uses jac_alg.
• zeta = Float64[]: Side-condition locations. Supply the points required by the problem; leave empty when the problem has no side conditions.
• jac_alg = BVPJacobianAlgorithm(): Jacobian construction strategy. For type stability, provide ForwardDiff chunk sizes in the AD types selected by this value.
• max_num_subintervals = 3000: Maximum number of mesh subintervals.

Example

alg = Ascher7(zeta = [0.0, 0.5, 1.0])

References

@article{Ascher1994CollocationSF,
    title={Collocation Software for Boundary Value Differential-Algebraic Equations},
    author={Uri M. Ascher and Raymond J. Spiteri},
    journal={SIAM J. Sci. Comput.},
    year={1994},
    volume={15},
    pages={938-952},
    url={https://api.semanticscholar.org/CorpusID:10597070}
}

@article{Ascher1979ACS,
    title={A collocation solver for mixed order systems of boundary value problems},
    author={Uri M. Ascher and J. Christiansen and Robert D. Russell},
    journal={Mathematics of Computation},
    year={1979},
    volume={33},
    pages={659-679},
    url={https://api.semanticscholar.org/CorpusID:121729124}
}

MIRKN4(; nlsolve = nothing, optimize = nothing, jac_alg = BVPJacobianAlgorithm(),
        defect_threshold = 0.1, max_num_subintervals = 3000)

4th order Monotonic Implicit Runge Kutta Nyström method.

Fields

• nlsolve: Optional nonlinear solver algorithm. nothing selects the package default.
• optimize: Optional optimization solver algorithm. nothing disables optimization-based initialization.
• jac_alg: Jacobian construction configuration used by the nonlinear solver.
• defect_threshold: Defect-control threshold used to refine the mesh.
• max_num_subintervals: Maximum number of mesh subintervals permitted during refinement.

Keyword Arguments

• nlsolve = nothing: Internal nonlinear solver. Any solver that conforms to the SciML NonlinearProblem interface can be used. Its autodiff setting is ignored because MIRKN uses jac_alg to construct the Jacobian.
• optimize = nothing: Internal optimization solver. Any solver that conforms to the SciML OptimizationProblem interface can be used for initialization. Load the solver package before constructing the algorithm.
• jac_alg = BVPJacobianAlgorithm(): Jacobian algorithm used for the nonlinear solver. It automatically selects an algorithm from the problem and input types.
  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff()). For bc_diffmode, defaults to AutoForwardDiff if possible else AutoFiniteDiff.
• defect_threshold = 0.1: Threshold for defect control.
• max_num_subintervals = 3000: Maximum number of mesh subintervals.

Examples

julia> using BoundaryValueDiffEqMIRKN: MIRKN4

julia> MIRKN4().max_num_subintervals
3000

References

@article{Muir2001MonoImplicitRM,
    title={Mono-Implicit Runge-Kutta-Nystr{"o}m Methods with Application to Boundary Value Ordinary Differential Equations},
    author={Paul H. Muir and Mark F. Adams},
    journal={BIT Numerical Mathematics},
    year={2001},
    volume={41},
    pages={776-799}
}

MIRKN6(; nlsolve = nothing, optimize = nothing, jac_alg = BVPJacobianAlgorithm(),
        defect_threshold = 0.1, max_num_subintervals = 3000)

6th order Monotonic Implicit Runge Kutta Nyström method.

Fields

• nlsolve: Optional nonlinear solver algorithm. nothing selects the package default.
• optimize: Optional optimization solver algorithm. nothing disables optimization-based initialization.
• jac_alg: Jacobian construction configuration used by the nonlinear solver.
• defect_threshold: Defect-control threshold used to refine the mesh.
• max_num_subintervals: Maximum number of mesh subintervals permitted during refinement.

Keyword Arguments

• nlsolve = nothing: Internal nonlinear solver. Any solver that conforms to the SciML NonlinearProblem interface can be used. Its autodiff setting is ignored because MIRKN uses jac_alg to construct the Jacobian.
• optimize = nothing: Internal optimization solver. Any solver that conforms to the SciML OptimizationProblem interface can be used for initialization. Load the solver package before constructing the algorithm.
• jac_alg = BVPJacobianAlgorithm(): Jacobian algorithm used for the nonlinear solver. It automatically selects an algorithm from the problem and input types.
  • For TwoPointBVProblem, only diffmode is used (defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff())).
  • For BVProblem, bc_diffmode and nonbc_diffmode are used. For nonbc_diffmode defaults to AutoSparse(AutoForwardDiff()) if possible else AutoSparse(AutoFiniteDiff()). For bc_diffmode, defaults to AutoForwardDiff if possible else AutoFiniteDiff.
• defect_threshold = 0.1: Threshold for defect control.
• max_num_subintervals = 3000: Maximum number of mesh subintervals.

Examples

julia> using BoundaryValueDiffEqMIRKN: MIRKN6

julia> MIRKN6().max_num_subintervals
3000

References

@article{Muir2001MonoImplicitRM,
    title={Mono-Implicit Runge-Kutta-Nystr{"o}m Methods with Application to Boundary Value Ordinary Differential Equations},
    author={Paul H. Muir and Mark F. Adams},
    journal={BIT Numerical Mathematics},
    year={2001},
    volume={41},
    pages={776-799}
}