OptimalControl.jl

OptimalControl.jl is the core package of the control-toolbox ecosystem. Below, we group together the documentation of all the functions and types exported by OptimalControl.

Beware!

Even if the following functions are prefixed by another package, such as CTFlows.Lift, they can all be used with OptimalControl. In fact, all functions prefixed with another package are simply reexported. For example, Lift is defined in CTFlows but accessible from OptimalControl.

julia

julia> using OptimalControl
julia> F(x) = 2x
julia> H = Lift(F)
julia> x = 1
julia> p = 2
julia> H(x, p)
4

Exported functions and types

OptimalControl.OptimalControl Module

julia

OptimalControl

High-level interface for solving optimal control problems.

This package provides a unified, user-friendly API for defining and solving optimal control problems using various discretization methods, NLP modelers, and solvers. It orchestrates the complete workflow from problem definition to solution.

Main Features

Flexible solve interface: Descriptive (symbolic) or explicit (typed components) modes
Multiple discretization methods: Collocation and other schemes via CTDirect
Multiple NLP modelers: ADNLP, ExaModels with CPU/GPU support
Multiple solvers: Ipopt, MadNLP, Uno, MadNCL, Knitro with CPU/GPU support
Automatic component completion: Partial specifications are completed intelligently
Option routing: Strategy-specific options are routed to the appropriate components

Usage

julia

using OptimalControl

# Define your optimal control problem
ocp = Model(...)
# ... problem definition ...

# Solve using descriptive mode (symbolic description)
sol = solve(ocp, :collocation, :adnlp, :ipopt)

# Or solve using explicit mode (typed components)
sol = solve(ocp; 
    discretizer=CTDirect.Collocation(),
    modeler=CTSolvers.ADNLP(),
    solver=CTSolvers.Ipopt()
)

Exported Names

See Also

solve: Main entry point for solving optimal control problems
methods: List available solving methods
CTBase: Core types and abstractions
CTDirect: Direct methods for discretization
CTSolvers: NLP solvers and orchestration

Documentation

Base.:* Method

julia

*(x, y...)

Multiplication operator.

Infix x*y*z*... calls this function with all arguments, i.e. *(x, y, z, ...), which by default then calls (x*y) * z * ... starting from the left.

Juxtaposition such as 2pi also calls *(2, pi). Note that this operation has higher precedence than a literal *. Note also that juxtaposition "0x..." (integer zero times a variable whose name starts with x) is forbidden as it clashes with unsigned integer literals: 0x01 isa UInt8.

Note that overflow is possible for most integer types, including the default Int, when multiplying large numbers.

Examples

julia

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

julia> [2 0; 0 3] * [1, 10]  # matrix * vector
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # juxtaposition has higher precedence
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # adjoint vector * vector
5

julia

*(
    F::CTFlowsODE.AbstractFlow,
    g::Tuple{Real, TF<:CTFlowsODE.AbstractFlow}
) -> Any

Shorthand for concatenate(F, g) when g is a tuple (t_switch, G).

Arguments

F::AbstractFlow: The first flow.
g::Tuple{ctNumber, AbstractFlow}: Tuple containing the switching time and second flow.

Returns

A new flow that switches from F to G at t_switch.

Example

julia

julia> F * (1.0, G)

julia

*(
    F::CTFlowsODE.AbstractFlow,
    g::Tuple{Real, Any, TF<:CTFlowsODE.AbstractFlow}
) -> Any

Shorthand for concatenate(F, g) when g is a tuple (t_switch, η_switch, G) including a jump.

Arguments

F::AbstractFlow: The first flow.
g::Tuple{ctNumber, Any, AbstractFlow}: Tuple with switching time, jump value, and second flow.

Returns

A flow with a jump at t_switch and a switch from F to G.

Example

julia

julia> F * (1.0, η, G)

CTFlows.Flow Function

julia

Flow(
    vf::CTFlows.VectorField;
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> CTFlowsODE.VectorFieldFlow

Constructs a flow object for a classical (non-Hamiltonian) vector field.

This creates a VectorFieldFlow that integrates the ODE system dx/dt = vf(t, x, v) using DifferentialEquations.jl. It handles both fixed and parametric dynamics, as well as jump discontinuities and event stopping.

Keyword Arguments

alg, abstol, reltol, saveat, internalnorm: Solver options.
kwargs_Flow...: Additional arguments passed to the solver configuration.

Example

julia

julia> vf(t, x, v) = -v * x
julia> flow = CTFlows.Flow(CTFlows.VectorField(vf))
julia> x1 = flow(0.0, 1.0, 1.0)

julia

Flow(
    h::CTFlows.AbstractHamiltonian;
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> CTFlowsODE.HamiltonianFlow

Constructs a Hamiltonian flow from a scalar Hamiltonian.

This method builds a numerical integrator that simulates the evolution of a Hamiltonian system given a Hamiltonian function h(t, x, p, l) or h(x, p).

Internally, it computes the right-hand side of Hamilton’s equations via automatic differentiation and returns a HamiltonianFlow object.

Keyword Arguments

alg, abstol, reltol, saveat, internalnorm: solver options.
kwargs_Flow...: forwarded to the solver.

Example

julia

julia> H(x, p) = dot(p, p) + dot(x, x)
julia> flow = CTFlows.Flow(CTFlows.Hamiltonian(H))
julia> xf, pf = flow(0.0, x0, p0, 1.0)

julia

Flow(
    hv::CTFlows.HamiltonianVectorField;
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> CTFlowsODE.HamiltonianFlow

Constructs a Hamiltonian flow from a precomputed Hamiltonian vector field.

This method assumes you already provide the Hamiltonian vector field (dx/dt, dp/dt) instead of deriving it from a scalar Hamiltonian.

Returns a HamiltonianFlow object that integrates the given system.

Keyword Arguments

alg, abstol, reltol, saveat, internalnorm: solver options.
kwargs_Flow...: forwarded to the solver.

Example

julia

julia> hv(t, x, p, l) = (∇ₚH, -∇ₓH)
julia> flow = CTFlows.Flow(CTFlows.HamiltonianVectorField(hv))
julia> xf, pf = flow(0.0, x0, p0, 1.0, l)

julia

Flow(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.AbstractTimesModel, <:CTModels.OCP.AbstractStateModel, CTModels.OCP.EmptyControlModel};
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> Union{CTFlowsODE.OptimalControlFlow{CTFlows.Fixed}, CTFlowsODE.OptimalControlFlow{CTFlows.NonFixed}}

Construct a flow for a control-free optimal control problem.

This method builds the Hamiltonian system for problems without control variables (parameter estimation, optimal design). The control is internally set to an empty array.

Arguments

ocp::ControlFreeModel: A control-free optimal control problem (with EmptyControlModel).
alg: Integration algorithm (default inferred).
abstol: Absolute tolerance for the ODE solver.
reltol: Relative tolerance for the ODE solver.
saveat: Time points at which to save the solution.
internalnorm: Optional norm function used by the integrator.
kwargs_Flow: Additional keyword arguments passed to the solver.

Returns

A flow object f such that:

f(t0, x0, p0, tf) integrates the state and costate from t0 to tf.
f((t0, tf), x0, p0) returns the full trajectory over the interval.

Example

julia

julia> # Control-free problem (parameter estimation)
julia> ocp = @def begin
           λ ∈ R, variable
           t ∈ [0, 10], time
           x ∈ R, state
           x(0) == 2.0
           ẋ(t) == λ * x(t)
           ∫((x(t) - data(t))^2) → min
       end

julia> f = Flow(ocp)
julia> sol = f((0.0, 10.0), x0, p0, λ)

Notes

This method is for control-free problems only. For problems with control variables, use Flow(ocp, u) instead.

julia

Flow(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.AbstractTimesModel, <:CTModels.OCP.AbstractStateModel, CTModels.OCP.ControlModel},
    u::CTFlows.ControlLaw;
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> Union{CTFlowsODE.OptimalControlFlow{CTFlows.Fixed}, CTFlowsODE.OptimalControlFlow{CTFlows.NonFixed}}

Construct a flow for an optimal control problem using a given control law.

This method builds the Hamiltonian system associated with the optimal control problem (ocp) and integrates the corresponding state–costate dynamics using the specified control law u.

Arguments

ocp::WithControlModel: An optimal control problem with control variables.
u::CTFlows.ControlLaw: A feedback control law generated by ControlLaw(...) or similar.
alg: Integration algorithm (default inferred).
abstol: Absolute tolerance for the ODE solver.
reltol: Relative tolerance for the ODE solver.
saveat: Time points at which to save the solution.
internalnorm: Optional norm function used by the integrator.
kwargs_Flow: Additional keyword arguments passed to the solver.

Returns

A flow object f such that:

f(t0, x0, p0, tf) integrates the state and costate from t0 to tf.
f((t0, tf), x0, p0) returns the full trajectory over the interval.

Throws

CTBase.Exceptions.PreconditionError: If called on a control-free problem (EmptyControlModel).

Example

julia

julia> u = (x, p) -> p
julia> f = Flow(ocp, ControlLaw(u))

Notes

For control-free problems (parameter estimation, optimal design), use Flow(ocp) instead.

julia

Flow(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.AbstractTimesModel, <:CTModels.OCP.AbstractStateModel, CTModels.OCP.EmptyControlModel},
    u::CTFlows.ControlLaw;
    kwargs...
)

Guard method that prevents providing a control law to a control-free problem.

Throws

CTBase.Exceptions.PreconditionError: Always throws with a clear error message.

julia

Flow(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.AbstractTimesModel, <:CTModels.OCP.AbstractStateModel, CTModels.OCP.ControlModel},
    u::Function;
    autonomous,
    variable,
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> Union{CTFlowsODE.OptimalControlFlow{CTFlows.Fixed}, CTFlowsODE.OptimalControlFlow{CTFlows.NonFixed}}

Construct a flow for an optimal control problem using a control function in feedback form.

This method constructs the Hamiltonian and integrates the associated state–costate dynamics using a raw function u. It automatically wraps u as a control law.

Arguments

ocp::WithControlModel: The optimal control problem with control variables.
u::Function: A feedback control function:
- If ocp is autonomous: u(x, p)
- If non-autonomous: u(t, x, p)
autonomous::Bool: Whether the control law depends on time.
variable::Bool: Whether the OCP involves variable time (e.g., free final time).
alg, abstol, reltol, saveat, internalnorm: ODE solver parameters.
kwargs_Flow: Additional options.

Returns

A Flow object compatible with function call interfaces for state propagation.

Example

julia

julia> u = (t, x, p) -> t + p
julia> f = Flow(ocp, u)

julia

Flow(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.AbstractTimesModel, <:CTModels.OCP.AbstractStateModel, CTModels.OCP.EmptyControlModel},
    u::Function;
    kwargs...
)

Guard method that prevents providing a control function to a control-free problem.

Throws

CTBase.Exceptions.PreconditionError: Always throws with a clear error message.

julia

Flow(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.AbstractTimesModel, <:CTModels.OCP.AbstractStateModel, CTModels.OCP.EmptyControlModel},
    g::CTFlows.StateConstraint{<:Function, T, V},
    μ::CTFlows.Multiplier{<:Function, T, V};
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> Union{CTFlowsODE.OptimalControlFlow{CTFlows.Fixed}, CTFlowsODE.OptimalControlFlow{CTFlows.NonFixed}}

Construct a flow for a control-free optimal control problem with state constraint and multiplier.

This method builds the Hamiltonian system for control-free problems with state constraints. The control is internally set to an empty array.

Arguments

ocp::ControlFreeModel: A control-free optimal control problem (with EmptyControlModel).
g::CTFlows.StateConstraint: State constraint function.
μ::CTFlows.Multiplier: Multiplier function associated with the constraint.
alg, abstol, reltol, saveat, internalnorm: Solver settings.
kwargs_Flow: Additional options.

Returns

A Flow object that integrates the constrained Hamiltonian dynamics.

Example

julia

julia> # Control-free problem with state constraint
julia> g = StateConstraint((x, v) -> x[1] - 1.0)
julia> μ = Multiplier((x, p, v) -> p[1])
julia> f = Flow(ocp, g, μ)

julia

Flow(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.AbstractTimesModel, <:CTModels.OCP.AbstractStateModel, CTModels.OCP.EmptyControlModel},
    g::Function,
    μ::Function;
    autonomous,
    variable,
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> Union{CTFlowsODE.OptimalControlFlow{CTFlows.Fixed}, CTFlowsODE.OptimalControlFlow{CTFlows.NonFixed}}

Construct a flow for a control-free problem with raw constraint and multiplier functions.

This version is for defining flows directly from user functions without wrapping them into StateConstraint or Multiplier types. Automatically wraps and adapts them based on time dependence.

Arguments

ocp::ControlFreeModel: The control-free optimal control problem.
g::Function: State constraint function.
μ::Function: Multiplier function.
autonomous::Bool: Whether the system is autonomous.
variable::Bool: Whether time is a free variable.
alg, abstol, reltol, saveat, internalnorm: Solver parameters.
kwargs_Flow: Additional options.

Returns

A Flow object ready for trajectory integration.

Example

julia

julia> # Control-free with raw functions
julia> f = Flow(ocp, (x, v) -> x[1] - 1.0, (x, p, v) -> p[1]; autonomous=true, variable=true)

julia

Flow(
    ocp::CTModels.OCP.Model,
    u::Union{CTFlows.ControlLaw{<:Function, T, V}, CTFlows.FeedbackControl{<:Function, T, V}},
    g::Union{CTFlows.MixedConstraint{<:Function, T, V}, CTFlows.StateConstraint{<:Function, T, V}},
    μ::CTFlows.Multiplier{<:Function, T, V};
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> Union{CTFlowsODE.OptimalControlFlow{CTFlows.Fixed}, CTFlowsODE.OptimalControlFlow{CTFlows.NonFixed}}

Construct a flow for an optimal control problem with control and constraint multipliers in feedback form.

This variant constructs a Hamiltonian system incorporating both the control law and a multiplier law (e.g., for enforcing state or mixed constraints). All inputs must be consistent in time dependence.

Arguments

ocp::CTModels.Model: The optimal control problem.
u::ControlLaw or FeedbackControl: Feedback control.
g::StateConstraint or MixedConstraint: Constraint function.
μ::Multiplier: Multiplier function.
alg, abstol, reltol, saveat, internalnorm: Solver settings.
kwargs_Flow: Additional options.

Returns

A Flow object that integrates the constrained Hamiltonian dynamics.

Example

julia

julia> f = Flow(ocp, (x, p) -> p[1], (x, u) -> x[1] - 1, (x, p) -> x[1]+p[1])

For non-autonomous cases:

julia

julia> f = Flow(ocp, (t, x, p) -> t + p, (t, x, u) -> x - 1, (t, x, p) -> x+p)

Warning

All input functions must match the autonomous/non-autonomous nature of the problem.

julia

Flow(
    ocp::CTModels.OCP.Model,
    u::Function,
    g::Function,
    μ::Function;
    autonomous,
    variable,
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> Union{CTFlowsODE.OptimalControlFlow{CTFlows.Fixed}, CTFlowsODE.OptimalControlFlow{CTFlows.NonFixed}}

Construct a flow from a raw feedback control, constraint, and multiplier.

This version is for defining flows directly from user functions without wrapping them into ControlLaw, Constraint, or Multiplier types. Automatically wraps and adapts them based on time dependence.

Arguments

ocp::CTModels.Model: The optimal control problem.
u::Function: Control law.
g::Function: Constraint.
μ::Function: Multiplier.
autonomous::Bool: Whether the system is autonomous.
variable::Bool: Whether time is a free variable.
alg, abstol, reltol, saveat, internalnorm: Solver parameters.
kwargs_Flow: Additional options.

Returns

A Flow object ready for trajectory integration.

julia

Flow(
    dyn::Function;
    autonomous,
    variable,
    alg,
    abstol,
    reltol,
    saveat,
    internalnorm,
    kwargs_Flow...
) -> CTFlowsODE.ODEFlow

Constructs a Flow from a user-defined dynamical system given as a Julia function.

This high-level interface handles:

autonomous and non-autonomous systems,
presence or absence of additional variables (v),
selection of ODE solvers and tolerances,
and integrates with the CTFlows event system (e.g., jumps, callbacks).

Arguments

dyn: A function defining the vector field. Its signature must match the values of autonomous and variable.
autonomous: Whether the dynamics are time-independent (false by default).
variable: Whether the dynamics depend on a control or parameter v.
alg, abstol, reltol, saveat, internalnorm: Solver settings passed to OrdinaryDiffEq.solve.
kwargs_Flow: Additional keyword arguments passed to the solver.

Returns

An ODEFlow object, wrapping both the full solver and its right-hand side (RHS).

Supported Function Signatures for dyn

Depending on the (autonomous, variable) flags:

(false, false): dyn(x)
(false, true): dyn(x, v)
(true, false): dyn(t, x)
(true, true): dyn(t, x, v)

Example

julia

julia> dyn(t, x, v) = [-x[1] + v[1] * sin(t)]
julia> flow = CTFlows.Flow(dyn; autonomous=true, variable=true)
julia> xT = flow((0.0, 1.0), [1.0], [0.1])

CTFlows.@Lie Macro

Compute Lie or Poisson brackets.

This macro provides a unified notation to define recursively nested Lie brackets (for vector fields) or Poisson brackets (for Hamiltonians).

Syntax

@Lie [F, G]: computes the Lie bracket [F, G] of two vector fields.
@Lie [[F, G], H]: supports arbitrarily nested Lie brackets.
@Lie {H, K}: computes the Poisson bracket {H, K} of two Hamiltonians.
@Lie {{H, K}, L}: supports arbitrarily nested Poisson brackets.
@Lie expr autonomous = false: specifies a non-autonomous system.
@Lie expr variable = true: indicates presence of an auxiliary variable v.

Keyword-like arguments can be provided to control the evaluation context for both Lie and Poisson brackets with raw functions:

autonomous = Bool: whether the system is time-independent (default: true).
variable = Bool: whether the system depends on an extra variable v (default: false).

Bracket type detection

Square brackets [...] denote Lie brackets between VectorField objects or raw functions.
Curly brackets {...} denote Poisson brackets between Hamiltonian objects or raw functions.
The macro automatically dispatches to _Lie_bracket or Poisson depending on the input pattern.
Raw functions are automatically wrapped in VectorField or Hamiltonian objects as needed.

Return

A callable object representing the specified Lie or Poisson bracket expression. The returned function can be evaluated like any other vector field or Hamiltonian.

Examples

■ Lie brackets with VectorField (autonomous)

julia

julia> F1 = VectorField(x -> [0, -x[3], x[2]])
julia> F2 = VectorField(x -> [x[3], 0, -x[1]])
julia> L = @Lie [F1, F2]
julia> L([1.0, 2.0, 3.0])
3-element Vector{Float64}:
  2.0
 -1.0
  0.0

■ Lie brackets with VectorField (non-autonomous, with auxiliary variable)

julia

julia> F1 = VectorField((t, x, v) -> [0, -x[3], x[2]]; autonomous=false, variable=true)
julia> F2 = VectorField((t, x, v) -> [x[3], 0, -x[1]]; autonomous=false, variable=true)
julia> L = @Lie [F1, F2]
julia> L(0.0, [1.0, 2.0, 3.0], 1.0)
3-element Vector{Float64}:
  2.0
 -1.0
  0.0

■ Lie brackets from raw functions (autonomous)

julia

julia> f1 = x -> [0, -x[3], x[2]]
julia> f2 = x -> [x[3], 0, -x[1]]
julia> L = @Lie [f1, f2]
julia> L([1.0, 2.0, 3.0])
3-element Vector{Float64}:
  2.0
 -1.0
  0.0

■ Lie bracket with non-autonomous raw functions

julia

julia> f1 = (t, x) -> [t, -x[3], x[2]]
julia> f2 = (t, x) -> [x[3], 0, -x[1]]
julia> L = @Lie [f1, f2] autonomous = false
julia> L(1.0, [1.0, 2.0, 3.0])
3-element Vector{Float64}:
  2.0
 -1.0
  0.0

■ Poisson brackets with Hamiltonian (autonomous)

julia

julia> H1 = Hamiltonian((x, p) -> x[1]^2 + p[2]^2)
julia> H2 = Hamiltonian((x, p) -> x[2]^2 + p[1]^2)
julia> P = @Lie {H1, H2}
julia> P([1.0, 1.0], [3.0, 2.0])
-4.0

■ Poisson brackets with Hamiltonian (non-autonomous, with variable)

julia

julia> H1 = Hamiltonian((t, x, p, v) -> x[1]^2 + p[2]^2 + v; autonomous=false, variable=true)
julia> H2 = Hamiltonian((t, x, p, v) -> x[2]^2 + p[1]^2 + v; autonomous=false, variable=true)
julia> P = @Lie {H1, H2}
julia> P(1.0, [1.0, 3.0], [4.0, 2.0], 3.0)
8.0

■ Poisson brackets from raw functions

julia

julia> H1 = (x, p) -> x[1]^2 + p[2]^2
julia> H2 = (x, p) -> x[2]^2 + p[1]^2
julia> P = @Lie {H1, H2}
julia> P([1.0, 1.0], [3.0, 2.0])
-4.0

■ Poisson bracket with non-autonomous raw functions

julia

julia> H1 = (t, x, p) -> x[1]^2 + p[2]^2 + t
julia> H2 = (t, x, p) -> x[2]^2 + p[1]^2 + t
julia> P = @Lie {H1, H2} autonomous = false
julia> P(3.0, [1.0, 2.0], [4.0, 1.0])
-8.0

■ Nested brackets

julia

julia> F = VectorField(x -> [-x[1], x[2], x[3]])
julia> G = VectorField(x -> [x[3], -x[2], 0])
julia> H = VectorField(x -> [0, 0, -x[1]])
julia> nested = @Lie [[F, G], H]
julia> nested([1.0, 2.0, 3.0])
3-element Vector{Float64}:
  2.0
  0.0
 -6.0

julia

julia> H1 = (x, p) -> x[2]*x[1]^2 + p[1]^2
julia> H2 = (x, p) -> x[1]*p[2]^2
julia> H3 = (x, p) -> x[1]*p[2] + x[2]*p[1]
julia> nested_poisson = @Lie {{H1, H2}, H3}
julia> nested_poisson([1.0, 2.0], [0.5, 1.0])
14.0

■ Mixed expressions with arithmetic

julia

julia> F1 = VectorField(x -> [0, -x[3], x[2]])
julia> F2 = VectorField(x -> [x[3], 0, -x[1]])
julia> x = [1.0, 2.0, 3.0]
julia> @Lie [F1, F2](x) + 3 * [F1, F2](x)
3-element Vector{Float64}:
  8.0
 -4.0
  0.0

julia

julia> H1 = (x, p) -> x[1]^2
julia> H2 = (x, p) -> p[1]^2
julia> H3 = (x, p) -> x[1]*p[1]
julia> x = [1.0, 2.0, 3.0]
julia> p = [3.0, 2.0, 1.0]
julia> @Lie {H1, H2}(x, p) + 2 * {H2, H3}(x, p)
24.0

CTFlows.Lie Function

Lie derivative of a scalar function along a vector field.

Example:

julia

julia> φ = x -> [x[2], -x[1]]
julia> X = VectorField(φ)
julia> f = x -> x[1]^2 + x[2]^2
julia> Lie(X,f)([1, 2])
0
julia> φ = (t, x, v) -> [t + x[2] + v[1], -x[1] + v[2]]
julia> X = VectorField(φ, NonAutonomous, NonFixed)
julia> f = (t, x, v) -> t + x[1]^2 + x[2]^2
julia> Lie(X, f)(1, [1, 2], [2, 1])
10

Lie derivative of a scalar function along a function with specified dependencies.

Example:

julia

julia> φ = x -> [x[2], -x[1]]
julia> f = x -> x[1]^2 + x[2]^2
julia> Lie(φ,f)([1, 2])
0
julia> φ = (t, x, v) -> [t + x[2] + v[1], -x[1] + v[2]]
julia> f = (t, x, v) -> t + x[1]^2 + x[2]^2
julia> Lie(φ, f, autonomous=false, variable=true)(1, [1, 2], [2, 1])
10

Lie bracket of two vector fields in the autonomous case.

Example:

julia

julia> f = x -> [x[2], 2x[1]]
julia> g = x -> [3x[2], -x[1]]
julia> X = VectorField(f)
julia> Y = VectorField(g)
julia> Lie(X, Y)([1, 2])
[7, -14]

Lie bracket of two vector fields in the nonautonomous case.

Example:

julia

julia> f = (t, x, v) -> [t + x[2] + v, -2x[1] - v]
julia> g = (t, x, v) -> [t + 3x[2] + v, -x[1] - v]
julia> X = VectorField(f, NonAutonomous, NonFixed)
julia> Y = VectorField(g, NonAutonomous, NonFixed)
julia> Lie(X, Y)(1, [1, 2], 1)
[-7, 12]

CTFlows.Lift Function

julia

Lift(
    X::CTFlows.VectorField
) -> CTFlows.HamiltonianLift{CTFlows.VectorField{TF, TD, VD}} where {TF<:Function, TD<:CTFlows.TimeDependence, VD<:CTFlows.VariableDependence}

Construct the Hamiltonian lift of a VectorField.

Arguments

X::VectorField: The vector field to lift. Its signature determines if it is autonomous and/or variable.

Returns

A HamiltonianLift callable object representing the Hamiltonian lift of X.

Examples

julia

julia> HL = Lift(VectorField(x -> [x[1]^2, x[2]^2], autonomous=true, variable=false))
julia> HL([1, 0], [0, 1])  # returns 0

julia> HL2 = Lift(VectorField((t, x, v) -> [t + x[1]^2, x[2]^2 + v], autonomous=false, variable=true))
julia> HL2(1, [1, 0], [0, 1], 1)  # returns 1

julia> H = Lift(x -> 2x)
julia> H(1, 1)  # returns 2

julia> H2 = Lift((t, x, v) -> 2x + t - v, autonomous=false, variable=true)
julia> H2(1, 1, 1, 1)  # returns 2

# Alternative syntax using symbols for autonomy and variability
julia> H3 = Lift((t, x, v) -> 2x + t - v, NonAutonomous, NonFixed)
julia> H3(1, 1, 1, 1)  # returns 2

julia

Lift(
    X::Function;
    autonomous,
    variable
) -> CTFlows.var"#21#22"{<:Function}

Construct the Hamiltonian lift of a function.

Arguments

X::Function: The function representing the vector field.
autonomous::Bool=true: Whether the function is autonomous (time-independent).
variable::Bool=false: Whether the function depends on an additional variable argument.

Returns

A callable function computing the Hamiltonian lift,

(and variants depending on autonomous and variable).

Details

Depending on the autonomous and variable flags, the returned function has one of the following call signatures:

(x, p) if autonomous=true and variable=false
(x, p, v) if autonomous=true and variable=true
(t, x, p) if autonomous=false and variable=false
(t, x, p, v) if autonomous=false and variable=true

Examples

julia

julia> H = Lift(x -> 2x)
julia> H(1, 1)  # returns 2

julia> H2 = Lift((t, x, v) -> 2x + t - v, autonomous=false, variable=true)
julia> H2(1, 1, 1, 1)  # returns 2

CTFlows.Poisson Function

julia

Poisson(
    f::CTFlows.AbstractHamiltonian{CTFlows.Autonomous, V<:CTFlows.VariableDependence},
    g::CTFlows.AbstractHamiltonian{CTFlows.Autonomous, V<:CTFlows.VariableDependence}
) -> Any

Poisson bracket of two Hamiltonian functions (subtype of AbstractHamiltonian). Autonomous case.

Returns a Hamiltonian representing the Poisson bracket {f, g} of two autonomous Hamiltonian functions f and g.

Example

julia

julia> f = (x, p) -> x[2]^2 + 2x[1]^2 + p[1]^2
julia> g = (x, p) -> 3x[2]^2 - x[1]^2 + p[2]^2 + p[1]
julia> F = Hamiltonian(f)
julia> G = Hamiltonian(g)
julia> Poisson(f, g)([1, 2], [2, 1])     # -20
julia> Poisson(f, G)([1, 2], [2, 1])     # -20
julia> Poisson(F, g)([1, 2], [2, 1])     # -20

julia

Poisson(
    f::CTFlows.AbstractHamiltonian{CTFlows.NonAutonomous, V<:CTFlows.VariableDependence},
    g::CTFlows.AbstractHamiltonian{CTFlows.NonAutonomous, V<:CTFlows.VariableDependence}
) -> Any

Poisson bracket of two Hamiltonian functions. Non-autonomous case.

Returns a Hamiltonian representing {f, g} where f and g are time-dependent.

Example

julia

julia> f = (t, x, p, v) -> t*v[1]*x[2]^2 + 2x[1]^2 + p[1]^2 + v[2]
julia> g = (t, x, p, v) -> 3x[2]^2 - x[1]^2 + p[2]^2 + p[1] + t - v[2]
julia> F = Hamiltonian(f, autonomous=false, variable=true)
julia> G = Hamiltonian(g, autonomous=false, variable=true)
julia> Poisson(F, G)(2, [1, 2], [2, 1], [4, 4])     # -76
julia> Poisson(f, g, NonAutonomous, NonFixed)(2, [1, 2], [2, 1], [4, 4])     # -76

julia

Poisson(
    f::CTFlows.HamiltonianLift{T<:CTFlows.TimeDependence, V<:CTFlows.VariableDependence},
    g::CTFlows.HamiltonianLift{T<:CTFlows.TimeDependence, V<:CTFlows.VariableDependence}
)

Poisson bracket of two HamiltonianLift vector fields.

Returns the HamiltonianLift corresponding to the Lie bracket of vector fields f.X and g.X.

Example

julia

julia> f = x -> [x[1]^2 + x[2]^2, 2x[1]^2]
julia> g = x -> [3x[2]^2, x[2] - x[1]^2]
julia> F = Lift(f)
julia> G = Lift(g)
julia> Poisson(F, G)([1, 2], [2, 1])     # -64

julia> f = (t, x, v) -> [t*v[1]*x[2]^2, 2x[1]^2 + v[2]]
julia> g = (t, x, v) -> [3x[2]^2 - x[1]^2, t - v[2]]
julia> F = Lift(f, NonAutonomous, NonFixed)
julia> G = Lift(g, NonAutonomous, NonFixed)
julia> Poisson(F, G)(2, [1, 2], [2, 1], [4, 4])     # 100

julia

Poisson(
    f::Function,
    g::Function;
    autonomous,
    variable
) -> CTFlows.Hamiltonian

Poisson bracket of two functions. The time and variable dependence are specified with keyword arguments.

Returns a Hamiltonian computed from the functions promoted as Hamiltonians.

Example

julia

julia> f = (x, p) -> x[2]^2 + 2x[1]^2 + p[1]^2
julia> g = (x, p) -> 3x[2]^2 - x[1]^2 + p[2]^2 + p[1]
julia> Poisson(f, g)([1, 2], [2, 1])     # -20

julia> f = (t, x, p, v) -> t*v[1]*x[2]^2 + 2x[1]^2 + p[1]^2 + v[2]
julia> g = (t, x, p, v) -> 3x[2]^2 - x[1]^2 + p[2]^2 + p[1] + t - v[2]
julia> Poisson(f, g, autonomous=false, variable=true)(2, [1, 2], [2, 1], [4, 4])     # -76

julia

Poisson(
    f::Function,
    g::CTFlows.AbstractHamiltonian{TD<:CTFlows.TimeDependence, VD<:CTFlows.VariableDependence}
) -> CTFlows.Hamiltonian

Poisson bracket of a function and a Hamiltonian.

Returns a Hamiltonian representing {f, g} where g is already a Hamiltonian.

Example

julia

julia> f = (x, p) -> x[2]^2 + 2x[1]^2 + p[1]^2
julia> g = (x, p) -> 3x[2]^2 - x[1]^2 + p[2]^2 + p[1]
julia> G = Hamiltonian(g)
julia> Poisson(f, G)([1, 2], [2, 1])     # -20

julia> f = (t, x, p, v) -> t*v[1]*x[2]^2 + 2x[1]^2 + p[1]^2 + v[2]
julia> g = (t, x, p, v) -> 3x[2]^2 - x[1]^2 + p[2]^2 + p[1] + t - v[2]
julia> G = Hamiltonian(g, autonomous=false, variable=true)
julia> Poisson(f, G)(2, [1, 2], [2, 1], [4, 4])     # -76

julia

Poisson(
    f::CTFlows.AbstractHamiltonian{TD<:CTFlows.TimeDependence, VD<:CTFlows.VariableDependence},
    g::Function
) -> CTFlows.Hamiltonian

Poisson bracket of a Hamiltonian and a function.

Returns a Hamiltonian representing {f, g} where f is already a Hamiltonian.

Example

julia

julia> f = (x, p) -> x[2]^2 + 2x[1]^2 + p[1]^2
julia> g = (x, p) -> 3x[2]^2 - x[1]^2 + p[2]^2 + p[1]
julia> F = Hamiltonian(f)
julia> Poisson(F, g)([1, 2], [2, 1])     # -20

julia> f = (t, x, p, v) -> t*v[1]*x[2]^2 + 2x[1]^2 + p[1]^2 + v[2]
julia> g = (t, x, p, v) -> 3x[2]^2 - x[1]^2 + p[2]^2 + p[1] + t - v[2]
julia> F = Hamiltonian(f, autonomous=false, variable=true)
julia> Poisson(F, g)(2, [1, 2], [2, 1], [4, 4])     # -76

CTModels.OCP.boundary_constraints_dual Function

julia

boundary_constraints_dual(
    model::CTModels.OCP.DualModel{<:Union{Nothing, Function}, BC_Dual<:Union{Nothing, AbstractVector{<:Real}}}
) -> Union{Nothing, AbstractVector{<:Real}}

Return the dual vector associated with the boundary constraints.

Arguments

model::DualModel: A model including dual variables for boundary constraints.

Returns

A vector of dual values, or nothing if not set.

julia

boundary_constraints_dual(
    sol::CTModels.OCP.Solution
) -> Union{Nothing, AbstractVector{<:Real}}

Return the dual of the boundary constraints.

CTModels.OCP.boundary_constraints_nl Function

julia

boundary_constraints_nl(
    model::CTModels.OCP.ConstraintsModel{<:Tuple, TB}
) -> Any

Get the nonlinear boundary constraints from the model.

Arguments

model: The constraints model from which to retrieve the boundary constraints.

Returns

The nonlinear boundary constraints.

Example

julia

# Example of retrieving nonlinear boundary constraints
julia> model = ConstraintsModel(...)
julia> boundary_constraints = boundary_constraints_nl(model)

julia

boundary_constraints_nl(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.TimesModel, <:CTModels.OCP.AbstractStateModel, <:CTModels.OCP.AbstractControlModel, <:CTModels.OCP.AbstractVariableModel, <:Function, <:CTModels.OCP.AbstractObjectiveModel, <:CTModels.OCP.ConstraintsModel{<:Tuple, TB<:Tuple}}
) -> Any

Return the nonlinear boundary constraints.

CTSolvers.Strategies.bypass Function

julia

bypass(val) -> CTSolvers.Strategies.BypassValue

Mark an option value to bypass validation.

This function creates a BypassValue wrapper around the provided value. When passed to a strategy constructor, this value will be accepted even if the option name is unknown (not in metadata) or if validation would otherwise fail.

This can be combined with route_to to bypass validation for specific strategies when routing ambiguous options.

Arguments

val: The option value to wrap

Returns

BypassValue: The wrapped value

Example

julia

julia> using CTSolvers.Strategies

julia> # Pass an unknown option directly to strategy
julia> solver = Ipopt(
           max_iter=100, 
           custom_backend_option=bypass(42)  # Bypasses validation
       )
Ipopt(options=StrategyOptions{...})

julia> # Alternative syntax using force alias
julia> solver = Ipopt(
           max_iter=100, 
           custom_backend_option=force(42)  # Same as bypass(42)
       )
Ipopt(options=StrategyOptions{...})

julia> # Combine with routing for ambiguous options
julia> solve(ocp, method; 
           backend = route_to(ipopt=bypass(42))  # Route to ipopt AND bypass validation
       )

Notes

Use with caution! Bypassed options are passed directly to the backend.
Typos in option names will not be caught by validation.
Invalid values for the backend will cause backend-level errors.
Can be combined with route_to for strategy-specific bypassing
force is an alias for bypass - they are identical functions

See also: BypassValue, route_to, force

CTModels.OCP.components Function

julia

components(model::CTModels.OCP.StateModel) -> Vector{String}

Get the components names of the state from the state model.

julia

components(
    model::CTModels.OCP.StateModelSolution
) -> Vector{String}

Get the components names of the state from the state model solution.

julia

components(
    model::CTModels.OCP.ControlModel
) -> Vector{String}

Get the names of the control components.

Arguments

model::ControlModel: The control model.

Returns

Vector{String}: A list of control component names.

Example

julia

julia> components(controlmodel)
["u₁", "u₂"]

julia

components(
    model::CTModels.OCP.ControlModelSolution
) -> Vector{String}

Get the names of the control components from the solution.

Arguments

model::ControlModelSolution: The control model solution.

Returns

Vector{String}: A list of control component names.

julia

components(
    _::CTModels.OCP.EmptyControlModel
) -> Vector{String}

Return an empty vector since there are no control components defined.

julia

components(
    model::CTModels.OCP.VariableModel
) -> Vector{String}

Return the names of the components of the variable.

julia

components(
    model::CTModels.OCP.VariableModelSolution
) -> Vector{String}

Return the names of the components from the variable solution.

julia

components(
    _::CTModels.OCP.EmptyVariableModel
) -> Vector{String}

Return an empty vector since there are no variable components defined.

CTModels.OCP.constraint Function

julia

constraint(
    model::CTModels.OCP.Model,
    label::Symbol
) -> Tuple{Symbol, Any, Any, Any}

Get a labelled constraint from the model. Returns a tuple of the form (type, f, lb, ub) where type is the type of the constraint, f is the function, lb is the lower bound and ub is the upper bound.

The function returns an exception if the label is not found in the model.

Arguments

model: The model from which to retrieve the constraint.
label: The label of the constraint to retrieve.

Returns

Tuple: A tuple containing the type, function, lower bound, and upper bound of the constraint.

CTModels.OCP.constraints Function

julia

constraints(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.AbstractTimesModel, <:CTModels.OCP.AbstractStateModel, <:CTModels.OCP.AbstractControlModel, <:CTModels.OCP.AbstractVariableModel, <:Function, <:CTModels.OCP.AbstractObjectiveModel, C<:CTModels.OCP.AbstractConstraintsModel}
) -> CTModels.OCP.AbstractConstraintsModel

Return the constraints struct.

CTModels.OCP.constraints_violation Function

julia

constraints_violation(sol::CTModels.OCP.Solution) -> Float64

Return the constraints violation.

CTModels.OCP.control Function

julia

control(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.TimesModel, <:CTModels.OCP.AbstractStateModel, T<:CTModels.OCP.AbstractControlModel}
) -> CTModels.OCP.AbstractControlModel

Return the control struct.

julia

control(
    sol::CTModels.OCP.Solution{<:CTModels.OCP.AbstractTimeGridModel, <:CTModels.OCP.AbstractTimesModel, <:CTModels.OCP.AbstractStateModel, <:CTModels.OCP.ControlModelSolution{TS<:Function}}
) -> Function

Return the control as a function of time.

julia

julia> u  = control(sol)
julia> t0 = time_grid(sol)[1]
julia> u0 = u(t0) # control at the initial time

julia

control(init::CTModels.Init.AbstractInitialGuess) -> Any

Return the control trajectory from an initial guess.

julia

control(sol::CTModels.OCP.AbstractSolution) -> Function

Return the control trajectory from a solution.

CTModels.OCP.control_components Function

julia

control_components(
    ocp::CTModels.OCP.Model
) -> Vector{String}

Return the names of the components of the control.

julia

control_components(
    sol::CTModels.OCP.Solution
) -> Vector{String}

Return the names of the components of the control.

CTModels.OCP.control_constraints_box Function

julia

control_constraints_box(
    model::CTModels.OCP.ConstraintsModel{<:Tuple, <:Tuple, <:Tuple, TC}
) -> Any

Get the control box constraints from the model.

Arguments

model: The constraints model from which to retrieve the control box constraints.

Returns

The control box constraints.

Example

julia

# Example of retrieving control box constraints
julia> model = ConstraintsModel(...)
julia> control_constraints = control_constraints_box(model)

julia

control_constraints_box(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.TimesModel, <:CTModels.OCP.AbstractStateModel, <:CTModels.OCP.AbstractControlModel, <:CTModels.OCP.AbstractVariableModel, <:Function, <:CTModels.OCP.AbstractObjectiveModel, <:CTModels.OCP.ConstraintsModel{<:Tuple, <:Tuple, <:Tuple, TC<:Tuple}}
) -> Any

Return the box constraints on control.

CTModels.OCP.control_constraints_lb_dual Function

julia

control_constraints_lb_dual(
    model::CTModels.OCP.DualModel{<:Union{Nothing, Function}, <:Union{Nothing, AbstractVector{<:Real}}, <:Union{Nothing, Function}, <:Union{Nothing, Function}, CC_LB_Dual<:Union{Nothing, Function}}
) -> Union{Nothing, Function}

Return the dual function associated with the lower bounds of control constraints.

Arguments

model::DualModel: A model including dual variables for control lower bounds.

Returns

A function mapping time t to a vector of dual values, or nothing if not set.

julia

control_constraints_lb_dual(
    sol::CTModels.OCP.Solution
) -> Union{Nothing, Function}

Return the lower bound dual of the control constraints.

CTModels.OCP.control_constraints_ub_dual Function

julia

control_constraints_ub_dual(
    model::CTModels.OCP.DualModel{<:Union{Nothing, Function}, <:Union{Nothing, AbstractVector{<:Real}}, <:Union{Nothing, Function}, <:Union{Nothing, Function}, <:Union{Nothing, Function}, CC_UB_Dual<:Union{Nothing, Function}}
) -> Union{Nothing, Function}

Return the dual function associated with the upper bounds of control constraints.

Arguments

model::DualModel: A model including dual variables for control upper bounds.

Returns

A function mapping time t to a vector of dual values, or nothing if not set.

julia

control_constraints_ub_dual(
    sol::CTModels.OCP.Solution
) -> Union{Nothing, Function}

Return the upper bound dual of the control constraints.

CTModels.OCP.control_dimension Function

julia

control_dimension(ocp::CTModels.OCP.Model) -> Int64

Return the control dimension.

julia

control_dimension(sol::CTModels.OCP.Solution) -> Int64

Return the dimension of the control.

CTModels.OCP.control_name Function

julia

control_name(ocp::CTModels.OCP.Model) -> String

Return the name of the control.

julia

control_name(sol::CTModels.OCP.Solution) -> String

Return the name of the control.

CTModels.OCP.costate Function

julia

costate(
    sol::CTModels.OCP.Solution{<:CTModels.OCP.AbstractTimeGridModel, <:CTModels.OCP.AbstractTimesModel, <:CTModels.OCP.AbstractStateModel, <:CTModels.OCP.AbstractControlModel, <:CTModels.OCP.AbstractVariableModel, <:CTModels.OCP.AbstractModel, Co<:Function}
) -> Function

Return the costate as a function of time.

julia

julia> p  = costate(sol)
julia> t0 = time_grid(sol)[1]
julia> p0 = p(t0) # costate at the initial time

CTModels.OCP.criterion Function

julia

criterion(model::CTModels.OCP.MayerObjectiveModel) -> Symbol

Return the criterion (:min or :max).

julia

criterion(
    model::CTModels.OCP.LagrangeObjectiveModel
) -> Symbol

Return the criterion (:min or :max).

julia

criterion(model::CTModels.OCP.BolzaObjectiveModel) -> Symbol

Return the criterion (:min or :max).

julia

criterion(ocp::CTModels.OCP.Model) -> Symbol

Return the type of criterion (:min or :max).

CTParser.@def Macro

Define an optimal control problem. One pass parsing of the definition. Can be used writing either ocp = @def begin ... end or @def ocp begin ... end. In the second case, setting log to true will display the parsing steps.

Example

julia

ocp = @def begin
    tf ∈ R, variable
    t ∈ [ 0, tf ], time
    x ∈ R², state
    u ∈ R, control
    tf ≥ 0
    -1 ≤ u(t) ≤ 1
    q = x₁
    v = x₂
    q(0) == 1
    v(0) == 2
    q(tf) == 0
    v(tf) == 0
    0 ≤ q(t) ≤ 5,       (1)
    -2 ≤ v(t) ≤ 3,      (2)
    ẋ(t) == [ v(t), u(t) ]
    tf → min
end

@def ocp begin
    tf ∈ R, variable
    t ∈ [ 0, tf ], time
    x ∈ R², state
    u ∈ R, control
    tf ≥ 0
    -1 ≤ u(t) ≤ 1
    q = x₁
    v = x₂
    q(0) == 1
    v(0) == 2
    q(tf) == 0
    v(tf) == 0
    0 ≤ q(t) ≤ 5,       (1)
    -2 ≤ v(t) ≤ 3,      (2)
    ẋ(t) == [ v(t), u(t) ]
    tf → min
end true # final boolean to show parsing log

CTModels.OCP.definition Function

julia

definition(
    ocp::CTModels.OCP.Model{<:CTModels.OCP.TimeDependence, <:CTModels.OCP.TimesModel, <:CTModels.OCP.AbstractStateModel, <:CTModels.OCP.AbstractControlModel, <:CTModels.OCP.AbstractVariableModel, <:Function, <:CTModels.OCP.AbstractObjectiveModel, <:CTModels.OCP.AbstractConstraintsModel, D<:CTModels.OCP.AbstractDefinition}
) -> CTModels.OCP.AbstractDefinition

Return the model definition of the optimal control problem.

Arguments

ocp::Model: The built optimal control problem model.

Returns

AbstractDefinition: The Definition wrapping the symbolic expression, or an EmptyDefinition if the user did not attach one before build.

CTModels.OCP.expression Function

julia

expression(_::CTModels.OCP.EmptyDefinition) -> Expr

Return an empty block expression for an EmptyDefinition.

Since no symbolic definition was attached, the canonical empty expression :(begin end) (equivalent to quote end) is returned.

Arguments

::EmptyDefinition: The empty definition sentinel.

Returns

Expr: An empty block expression :(begin end).

julia

expression(d::CTModels.OCP.Definition) -> Expr

Return the symbolic expression wrapped by a Definition.

Arguments

d::Definition: The definition holding the symbolic expression.

Returns

Expr: The Expr value stored in d.expr.

julia

expression(ocp::CTModels.OCP.Model) -> Expr

Return the symbolic expression of the model definition of a built optimal control problem.

Delegates to expression on the underlying AbstractDefinition: returns d.expr if a Definition was attached before build, or :(begin end) if the definition is an EmptyDefinition.

Arguments

ocp::Model: The built optimal control problem model.

Returns

Expr: The symbolic expression, or :(begin end) if no definition was attached.

CTSolvers.Strategies.describe Function

Display detailed information about a strategy type, including its id, supertype, and full metadata with all available option definitions.

This function is useful for discovering what options a strategy accepts before constructing an instance.

Arguments

strategy_type::Type{<:AbstractStrategy}: The strategy type to describe

Example

julia

julia> describe(Modelers.ADNLP)
Modelers.ADNLP (strategy type)
├─ id: :adnlp
├─ supertype: AbstractNLPModeler
└─ metadata: 4 options defined
   ├─ show_time :: Bool (default: false)
   │  description: Whether to show timing information
   ├─ backend :: Symbol (default: optimized)
   │  description: AD backend used by ADNLPModels
   └─ matrix_free :: Bool (default: false)
      description: Enable matrix-free mode

OptimalControl.jl ​

Exported functions and types ​

Documentation ​

OptimalControl.jl

Exported functions and types

Documentation