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].

• platform = CPU(): KernelAbstractions backend used to evaluate the per-interval internal ODE solves when the internal ensemblealg is EnsembleThreads (the default). Currently only the CPU backend is supported, since the internal solves run through the standard ODE integrator interface.

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.
• platform: KernelAbstractions backend used for the internal ODE solves.
• 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(), platform = CPU(),
        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.

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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(), platform = CPU(),
        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.

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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(), platform = CPU(),
        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.

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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(), platform = CPU(),
        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.

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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(), platform = CPU(),
        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.

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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, platform = CPU(),
    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().

• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().

• 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(), platform = CPU(),
    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.
• platform: KernelAbstractions backend used to assemble the collocation equations.
• 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.
• platform: KernelAbstractions backend used to assemble the collocation equations. Defaults to CPU().
• 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(), platform = CPU(),
    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.
• platform: KernelAbstractions backend used to assemble the collocation equations.
• 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.
• platform: KernelAbstractions backend used to assemble the collocation equations. Defaults to CPU().
• 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(), platform = CPU(),
    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.
• platform: KernelAbstractions backend used to assemble the collocation equations.
• 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.
• platform: KernelAbstractions backend used to assemble the collocation equations. Defaults to CPU().
• 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(), platform = CPU(),
    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.
• platform: KernelAbstractions backend used to assemble the collocation equations.
• 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.
• platform: KernelAbstractions backend used to assemble the collocation equations. Defaults to CPU().
• 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(), platform = CPU(),
    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.
• platform: KernelAbstractions backend used to assemble the collocation equations.
• 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.
• platform: KernelAbstractions backend used to assemble the collocation equations. Defaults to CPU().
• 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(), platform = CPU(),
    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.
• platform: KernelAbstractions backend used to assemble the collocation equations.
• 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.
• platform: KernelAbstractions backend used to assemble the collocation equations. Defaults to CPU().
• 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(), platform = CPU(),
    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.
• platform: KernelAbstractions backend used to assemble the collocation equations.
• 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.
• platform: KernelAbstractions backend used to assemble the collocation equations. Defaults to CPU().
• 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(),
        platform = CPU(), 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.
• platform: KernelAbstractions backend used to evaluate the collocation equations.
• 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.
• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().
• 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(),
        platform = CPU(), 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.
• platform: KernelAbstractions backend used to evaluate the collocation equations.
• 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.
• platform: KernelAbstractions backend used to evaluate the collocation equations. Defaults to CPU().
• 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}
}