CTModels.jl

CTModels module.

Lists all the imported modules and packages:

• Base
• Core
• DocStringExtensions
• Interpolations
• MLStyle
• Parameters
• PrettyTables

List of all the exported names:

• plot
• plot!

plot(sol::CTModels.AbstractSolution; kwargs...)

Plot a solution.

Type alias for a grid of times. This is used to define a discretization of time interval given to solvers.

julia> const TimesDisc = Union{Times, StepRangeLen}

See also: Time, Times.

abstract type AbstractConstraintsModel

abstract type AbstractControlModel

abstract type AbstractDualModel

abstract type AbstractModel

abstract type AbstractObjectiveModel

abstract type AbstractSolution

abstract type AbstractSolverInfos

abstract type AbstractStateModel

abstract type AbstractTag

Abstract type for export/import functions, used to choose between JSON or JLD extensions.

abstract type AbstractTimeGridModel

abstract type AbstractTimeModel

abstract type AbstractTimesModel

abstract type AbstractVariableModel

struct BolzaObjectiveModel{TM<:Function, TL<:Function} <: CTModels.AbstractObjectiveModel

Fields

• mayer::Function

• lagrange::Function

• criterion::Symbol

Type alias for a dictionnary of constraints. This is used to store constraints before building the model.

julia> const TimesDisc = Union{Times, StepRangeLen}

See also: ConstraintsModel, PreModel and Model.

struct ConstraintsModel{TP<:Tuple, TB<:Tuple, TS<:Tuple, TC<:Tuple, TV<:Tuple} <: CTModels.AbstractConstraintsModel

Fields

• path_nl::Tuple

• boundary_nl::Tuple

• state_box::Tuple

• control_box::Tuple

• variable_box::Tuple

struct ControlModel <: CTModels.AbstractControlModel

Fields

• name::String

• components::Vector{String}

struct ControlModelSolution{TS<:Function} <: CTModels.AbstractControlModel

Fields

• name::String

• components::Vector{String}

• value::Function

Type alias for a dimension. This is used to define the dimension of the state space, the costate space, the control space, etc.

julia> const Dimension = Integer

struct DualModel{PC_Dual<:Union{Nothing, Function}, BC_Dual<:Union{Nothing, AbstractVector{<:Real}}, SC_LB_Dual<:Union{Nothing, Function}, SC_UB_Dual<:Union{Nothing, Function}, CC_LB_Dual<:Union{Nothing, Function}, CC_UB_Dual<:Union{Nothing, Function}, VC_LB_Dual<:Union{Nothing, AbstractVector{<:Real}}, VC_UB_Dual<:Union{Nothing, AbstractVector{<:Real}}} <: CTModels.AbstractDualModel

Fields

• path_constraints_dual::Union{Nothing, Function}

• boundary_constraints_dual::Union{Nothing, AbstractVector{<:Real}}

• state_constraints_lb_dual::Union{Nothing, Function}

• state_constraints_ub_dual::Union{Nothing, Function}

• control_constraints_lb_dual::Union{Nothing, Function}

• control_constraints_ub_dual::Union{Nothing, Function}

• variable_constraints_lb_dual::Union{Nothing, AbstractVector{<:Real}}

• variable_constraints_ub_dual::Union{Nothing, AbstractVector{<:Real}}

struct EmptyTimeGridModel <: CTModels.AbstractTimeGridModel

Fields

struct EmptyVariableModel <: CTModels.AbstractVariableModel

Fields

struct FixedTimeModel{T<:Real} <: CTModels.AbstractTimeModel

Fields

• time::Real

• name::String

struct FreeTimeModel <: CTModels.AbstractTimeModel

Fields

• index::Int64

• name::String

Initial guess for OCP, contains

• functions of time for the state and control variables
• vector for optimization variables

Initialization data for each field can be left to default or:

• vector for optimization variables
• constant / vector / function for state and control
• existing solution ('warm start') for all fields

Constructors:

• Init(): default initialization
• Init(state, control, variable, time): constant vector, function handles and / or matrices / vectors interpolated along given time grid
• Init(sol): from existing solution

Examples

julia> init = Init()
julia> init = Init(state=[0.1, 0.2], control=0.3)
julia> init = Init(state=[0.1, 0.2], control=0.3, variable=0.5)
julia> init = Init(state=[0.1, 0.2], controlt=t->sin(t), variable=0.5)
julia> init = Init(state=[[0, 0], [1, 2], [5, -1]], time=[0, .3, 1.], controlt=t->sin(t))
julia> init = Init(sol)

struct JLD2Tag <: CTModels.AbstractTag

JLD tag for export/import functions.

struct JSON3Tag <: CTModels.AbstractTag

JSON tag for export/import functions.

struct LagrangeObjectiveModel{TL<:Function} <: CTModels.AbstractObjectiveModel

Fields

• lagrange::Function

• criterion::Symbol

struct MayerObjectiveModel{TM<:Function} <: CTModels.AbstractObjectiveModel

Fields

• mayer::Function

• criterion::Symbol

struct Model{TimesModelType<:CTModels.AbstractTimesModel, StateModelType<:CTModels.AbstractStateModel, ControlModelType<:CTModels.AbstractControlModel, VariableModelType<:CTModels.AbstractVariableModel, DynamicsModelType<:Function, ObjectiveModelType<:CTModels.AbstractObjectiveModel, ConstraintsModelType<:CTModels.AbstractConstraintsModel} <: CTModels.AbstractModel

Fields

• times::CTModels.AbstractTimesModel

• state::CTModels.AbstractStateModel

• control::CTModels.AbstractControlModel

• variable::CTModels.AbstractVariableModel

• dynamics::Function

• objective::CTModels.AbstractObjectiveModel

• constraints::CTModels.AbstractConstraintsModel

• definition::Expr

mutable struct PreModel <: CTModels.AbstractModel

Fields

• times::Union{Nothing, CTModels.AbstractTimesModel}: Default: nothing

• state::Union{Nothing, CTModels.AbstractStateModel}: Default: nothing

• control::Union{Nothing, CTModels.AbstractControlModel}: Default: nothing

• variable::CTModels.AbstractVariableModel: Default: EmptyVariableModel()

• dynamics::Union{Nothing, Function}: Default: nothing

• objective::Union{Nothing, CTModels.AbstractObjectiveModel}: Default: nothing

• constraints::OrderedCollections.OrderedDict{Symbol, Tuple{Symbol, Union{Function, OrdinalRange{<:Int64}}, AbstractVector{<:Real}, AbstractVector{<:Real}}}: Default: ConstraintsDictType()

• definition::Union{Nothing, Expr}: Default: nothing

struct Solution{TimeGridModelType<:CTModels.AbstractTimeGridModel, TimesModelType<:CTModels.AbstractTimesModel, StateModelType<:CTModels.AbstractStateModel, ControlModelType<:CTModels.AbstractControlModel, VariableModelType<:CTModels.AbstractVariableModel, CostateModelType<:Function, ObjectiveValueType<:Real, DualModelType<:CTModels.AbstractDualModel, SolverInfosType<:CTModels.AbstractSolverInfos} <: CTModels.AbstractSolution

Fields

• time_grid::CTModels.AbstractTimeGridModel

• times::CTModels.AbstractTimesModel

• state::CTModels.AbstractStateModel

• control::CTModels.AbstractControlModel

• variable::CTModels.AbstractVariableModel

• costate::Function

• objective::Real

• dual::CTModels.AbstractDualModel

• solver_infos::CTModels.AbstractSolverInfos

struct SolverInfos{TI<:Dict{Symbol, Any}} <: CTModels.AbstractSolverInfos

Fields

• iterations::Int64

• stopping::Symbol

• message::String

• success::Bool

• constraints_violation::Float64

• infos::Dict{Symbol, Any}

struct StateModel <: CTModels.AbstractStateModel

Fields

• name::String

• components::Vector{String}

struct StateModelSolution{TS<:Function} <: CTModels.AbstractStateModel

Fields

• name::String

• components::Vector{String}

• value::Function

Type alias for a time.

julia> const Time = ctNumber

See also: ctNumber, Times, TimesDisc.

struct TimeGridModel{T<:Union{StepRangeLen, AbstractVector{<:Real}}} <: CTModels.AbstractTimeGridModel

Fields

• value::Union{StepRangeLen, AbstractVector{<:Real}}

Type alias for a vector of times.

julia> const Times = AbstractVector{<:Time}

See also: Time, TimesDisc.

struct TimesModel{TI<:CTModels.AbstractTimeModel, TF<:CTModels.AbstractTimeModel} <: CTModels.AbstractTimesModel

Fields

• initial::CTModels.AbstractTimeModel

• final::CTModels.AbstractTimeModel

• time_name::String

struct VariableModel <: CTModels.AbstractVariableModel

Fields

• name::String

• components::Vector{String}

struct VariableModelSolution{TS<:Union{Real, AbstractVector{<:Real}}} <: CTModels.AbstractVariableModel

Fields

• name::String

• components::Vector{String}

• value::Union{Real, AbstractVector{<:Real}}

Type alias for a real number.

julia> const ctNumber = Real

Type alias for a vector of real numbers.

julia> const ctVector = AbstractVector{<:ctNumber}

See also: ctNumber.

isempty(model::CTModels.ConstraintsModel) -> Bool

Return if the constraints model is empty or not.

show(
    io::IO,
    _::MIME{Symbol("text/plain")},
    ocp::CTModels.PreModel
)

Print the optimal control problem.

show(
    io::IO,
    _::MIME{Symbol("text/plain")},
    sol::CTModels.Solution
)

Prints the solution.

show(io::IO, _::MIME{Symbol("text/plain")}, ocp::Model)

Print the optimal control problem.

show_default(io::IO, ocp::CTModels.PreModel)

show_default(io::IO, sol::CTModels.Solution)

__constraint!(
    ocp_constraints::OrderedCollections.OrderedDict{Symbol, Tuple{Symbol, Union{Function, OrdinalRange{<:Int64}}, AbstractVector{<:Real}, AbstractVector{<:Real}}},
    type::Symbol,
    n::Int64,
    m::Int64,
    q::Int64;
    rg,
    f,
    lb,
    ub,
    label
)

Add a constraint to a dictionary of constraints.

Arguments

• ocp_constraints: The dictionary of constraints to which the constraint will be added.
• type: The type of the constraint. It can be :state, :control, :variable, :boundary or :path.
• n: The dimension of the state.
• m: The dimension of the control.
• q: The dimension of the variable.
• rg: The range of the constraint. It can be an integer or a range of integers.
• f: The function that defines the constraint. It must return a vector of the same dimension as the constraint.
• lb: The lower bound of the constraint. It can be a number or a vector.
• ub: The upper bound of the constraint. It can be a number or a vector.
• label: The label of the constraint. It must be unique in the dictionary of constraints.

Requirements

• The constraint must not be set before.
• The lower bound lb and the upper bound ub cannot be both nothing.
• The lower bound lb and the upper bound ub must have the same length, if both provided.

If rg and f are not provided then,

• type must be :state, :control or :variable
• lb and ub must be of dimension n, m or q respectively, when provided.

If rg is provided, then:

• f must not be provided.
• type must be :state, :control or :variable.
• rg must be a range of integers, and must be contained in 1:n, 1:m or 1:q respectively.

If f is provided, then:

• rg must not be provided.
• type must be :boundary or :path.
• f must be a function that returns a vector of the same dimension as the constraint.
• lb and ub must be of the same dimension as the output of f, when provided.

__constraint_label() -> Symbol

Used to set the default value of the label of a constraint. A unique value is given to each constraint using the gensym function and prefixing by :unamed.

__constraints()

Used to set the default value for the constraints.

__control_components(
    m::Int64,
    name::String
) -> Vector{String}

Used to set the default value of the names of the controls. The default value is ["u"] for a one dimensional control, and ["u₁", "u₂", ...] for a multi dimensional control.

__control_name() -> String

Used to set the default value of the names of the control. The default value is "u".

__criterion_type() -> Symbol

Used to set the default value of the type of criterion. Either :min or :max. The default value is :min. The other possible criterion type is :max.

__format() -> Symbol

Used to set the default value of the format of the file to be used for export and import.

__is_consistent(ocp::CTModels.PreModel) -> Bool

__is_control_set(ocp::CTModels.PreModel) -> Bool

__is_control_set(ocp::Model) -> Bool

__is_definition_set(ocp::CTModels.PreModel) -> Bool

__is_definition_set(ocp::Model) -> Bool

__is_dynamics_set(ocp::CTModels.PreModel) -> Bool

__is_dynamics_set(ocp::Model) -> Bool

__is_empty(ocp::CTModels.PreModel) -> Bool

__is_objective_set(ocp::CTModels.PreModel) -> Bool

__is_objective_set(ocp::Model) -> Bool

__is_state_set(ocp::CTModels.PreModel) -> Bool

__is_state_set(ocp::Model) -> Bool

__is_times_set(ocp::CTModels.PreModel) -> Bool

__is_times_set(ocp::Model) -> Bool

__is_variable_set(ocp::CTModels.PreModel) -> Bool

__is_variable_set(ocp::Model) -> Bool

__matrix_dimension_storage() -> Int64

Used to set the default value of the storage of elements in a matrix. The default value is 1.

__state_components(n::Int64, name::String) -> Vector{String}

Used to set the default value of the names of the states. The default value is ["x"] for a one dimensional state, and ["x₁", "x₂", ...] for a multi dimensional state.

__state_name() -> String

Used to set the default value of the name of the state. The default value is "x".

__time_name() -> String

Used to set the default value of the name of the time. The default value is t.

__variable_components(
    q::Int64,
    name::String
) -> Vector{String}

Used to set the default value of the names of the variables. The default value is ["v"] for a one dimensional variable, and ["v₁", "v₂", ...] for a multi dimensional variable.

__variable_name(q::Int64) -> String

Used to set the default value of the names of the variables. The default value is "v".

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

Return the dual of the boundary constraints of the optimal control solution.

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

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

Get the nonlinear boundary constraints from the model.

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

Get the nonlinear boundary constraints from the model.

buildFunctionalInit(data, time, dim) -> CTModels.var"#25#26"

Build functional initialization: general interpolation case

buildFunctionalInit(
    data::Function,
    time,
    dim
) -> CTModels.var"#27#28"{<:Function}

Build functional initialization: function case

buildFunctionalInit(
    data::Nothing,
    time,
    dim
) -> CTModels.var"#25#26"

Build functional initialization: default case

buildFunctionalInit(
    data::Union{Real, AbstractVector{<:Real}},
    time,
    dim
) -> Union{CTModels.var"#29#31", CTModels.var"#30#32"}

Build functional initialization: constant / 1D interpolation

buildVectorInit(data, dim) -> Any

Build vector initialization: default / vector case

build_constraints(
    constraints::OrderedCollections.OrderedDict{Symbol, Tuple{Symbol, Union{Function, OrdinalRange{<:Int64}}, AbstractVector{<:Real}, AbstractVector{<:Real}}}
) -> CTModels.ConstraintsModel{TP, TB, Tuple{Vector{Real}, Vector{Int64}, Vector{Real}, Vector{Symbol}}, Tuple{Vector{Real}, Vector{Int64}, Vector{Real}, Vector{Symbol}}, Tuple{Vector{Real}, Vector{Int64}, Vector{Real}, Vector{Symbol}}} where {TP<:Tuple{Vector{Real}, Any, Vector{Real}, Vector{Symbol}}, TB<:Tuple{Vector{Real}, Any, Vector{Real}, Vector{Symbol}}}

Build a concrete type constraints model from a dictionary of constraints.

build_model(
    pre_ocp::CTModels.PreModel
) -> Model{TimesModelType, StateModelType, ControlModelType, VariableModelType, DynamicsModelType, ObjectiveModelType, ConstraintsModelType} where {TimesModelType<:CTModels.AbstractTimesModel, StateModelType<:CTModels.AbstractStateModel, ControlModelType<:CTModels.AbstractControlModel, VariableModelType<:CTModels.AbstractVariableModel, DynamicsModelType<:Function, ObjectiveModelType<:CTModels.AbstractObjectiveModel, ConstraintsModelType<:(CTModels.ConstraintsModel{TP, TB, Tuple{Vector{Real}, Vector{Int64}, Vector{Real}, Vector{Symbol}}, Tuple{Vector{Real}, Vector{Int64}, Vector{Real}, Vector{Symbol}}, Tuple{Vector{Real}, Vector{Int64}, Vector{Real}, Vector{Symbol}}} where {TP<:Tuple{Vector{Real}, Any, Vector{Real}, Vector{Symbol}}, TB<:Tuple{Vector{Real}, Any, Vector{Real}, Vector{Symbol}}})}

Build a concrete type model from a pre-model.

build_solution(
    ocp::Model,
    T::Vector{Float64},
    X::Union{Function, Matrix{Float64}},
    U::Union{Function, Matrix{Float64}},
    v::Vector{Float64},
    P::Union{Function, Matrix{Float64}};
    objective,
    iterations,
    constraints_violation,
    message,
    stopping,
    success,
    path_constraints_dual,
    boundary_constraints_dual,
    state_constraints_lb_dual,
    state_constraints_ub_dual,
    control_constraints_lb_dual,
    control_constraints_ub_dual,
    variable_constraints_lb_dual,
    variable_constraints_ub_dual
)

Build a solution from the optimal control problem, the time grid, the state, control, variable, and dual variables.

Arguments

• ocp::Model: the optimal control problem.
• T::Vector{Float64}: the time grid.
• X::Matrix{Float64}: the state trajectory.
• U::Matrix{Float64}: the control trajectory.
• v::Vector{Float64}: the variable trajectory.
• P::Matrix{Float64}: the costate trajectory.
• objective::Float64: the objective value.
• iterations::Int: the number of iterations.
• constraints_violation::Float64: the constraints violation.
• message::String: the message associated to the stopping criterion.
• stopping::Symbol: the stopping criterion.
• success::Bool: the success status.
• path_constraints_dual::Matrix{Float64}: the dual of the path constraints.
• boundary_constraints_dual::Vector{Float64}: the dual of the boundary constraints.
• state_constraints_lb_dual::Matrix{Float64}: the lower bound dual of the state constraints.
• state_constraints_ub_dual::Matrix{Float64}: the upper bound dual of the state constraints.
• control_constraints_lb_dual::Matrix{Float64}: the lower bound dual of the control constraints.
• control_constraints_ub_dual::Matrix{Float64}: the upper bound dual of the control constraints.
• variable_constraints_lb_dual::Vector{Float64}: the lower bound dual of the variable constraints.
• variable_constraints_ub_dual::Vector{Float64}: the upper bound dual of the variable constraints.

Returns

• sol::Solution: the optimal control solution.

checkDim(actual_dim, target_dim)

Check if actual dimension is equal to target dimension, error otherwise

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

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

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

Get the components names of the control from the model.

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

Get the components names of the variable from the empty variable model. Return an empty vector.

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

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

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

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

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

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

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

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

constraint!(
    ocp::CTModels.PreModel,
    type::Symbol;
    rg,
    f,
    lb,
    ub,
    label
)

Add a constraint to a pre-model. See [__constraint!](@ref) for more details.

constraint(
    model::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 of the constraint, lb is the lower bound of the constraint and ub is the upper bound of the constraint.

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

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

Get the constraints from the model.

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

Return the constraints violation of the optimal control solution.

control!(ocp::CTModels.PreModel, m::Int64)
control!(
    ocp::CTModels.PreModel,
    m::Int64,
    name::Union{String, Symbol}
)
control!(
    ocp::CTModels.PreModel,
    m::Int64,
    name::Union{String, Symbol},
    components_names::Array{T2<:Union{String, Symbol}, 1}
)

Define the control dimension and possibly the names of each coordinate.

Examples

julia> control!(ocp, 1)
julia> control_dimension(ocp)
1
julia> control_components(ocp)
["u"]

julia> control!(ocp, 1, "v")
julia> control_dimension(ocp)
1
julia> control_components(ocp)
["v"]

julia> control!(ocp, 2)
julia> control_dimension(ocp)
2
julia> control_components(ocp)
["u₁", "u₂"]

julia> control!(ocp, 2, :v)
julia> control_dimension(ocp)
2
julia> control_components(ocp)
["v₁", "v₂"]

julia> control!(ocp, 2, "v")
julia> control_dimension(ocp)
2
julia> control_components(ocp)
["v₁", "v₂"]

julia> control!(ocp, 2, "v", ["a", "b"])
julia> control_dimension(ocp)
2
julia> control_components(ocp)
["a", "b"]

julia> control!(ocp, 2, "v", [:a, :b])
julia> control_dimension(ocp)
2
julia> control_components(ocp)
["a", "b"]

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

Return the control (function of time) of the optimal control solution.

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

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

Get the control from the model.

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

Return the names of the components of the control of the optimal control solution.

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

Get the components names of the control from the model.

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

Get the control box constraints from the model.

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

Get the box constraints on control from the model.

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

Return the lower bound dual of the control constraints of the optimal control solution.

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

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

Return the upper bound dual of the control constraints of the optimal control solution.

control_constraints_ub_dual(
    model::CTModels.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}

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

Return the dimension of the control of the optimal control solution.

control_dimension(ocp::Model) -> Int64

Get the control dimension from the model.

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

Return the name of the control of the optimal control solution.

control_name(ocp::Model) -> String

Get the name of the control from the model.

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

Return the costate of the optimal control solution.

julia> t0 = time_grid(sol)[1]
julia> p  = costate(sol)
julia> p0 = p(t0)

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

Get the criterion (:min or :max) of the Bolza objective model.

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

Get the criterion (:min or :max) of the Lagrange objective model.

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

Get the criterion (:min or :max) of the Mayer objective model.

criterion(ocp::Model) -> Symbol

Get the type of criterion (:min or :max) from the model.

ctinterpolate(x, f) -> Any

Return the interpolation of f at x.

definition!(ocp::CTModels.PreModel, definition::Expr)

Set the model definition of the optimal control problem.

definition(ocp::CTModels.PreModel) -> Union{Nothing, Expr}

Return the model definition of the optimal control problem or nothing.

definition(ocp::Model) -> Expr

Return the model definition of the optimal control problem.

dim_boundary_constraints_nl(
    model::CTModels.ConstraintsModel
) -> Int64

Return the dimension of nonlinear boundary constraints.

dim_boundary_constraints_nl(ocp::Model) -> Int64

Return the dimension of the boundary constraints.

dim_control_constraints_box(
    model::CTModels.ConstraintsModel
) -> Int64

Return the dimension of control box constraints.

dim_control_constraints_box(ocp::Model) -> Int64

Return the dimension of box constraints on control.

dim_path_constraints_nl(
    model::CTModels.ConstraintsModel
) -> Int64

Return the dimension of nonlinear path constraints.

dim_path_constraints_nl(ocp::Model) -> Int64

Return the dimension of nonlinear path constraints.

dim_state_constraints_box(
    model::CTModels.ConstraintsModel
) -> Int64

Return the dimension of state box constraints.

dim_state_constraints_box(ocp::Model) -> Int64

Return the dimension of box constraints on state.

dim_variable_constraints_box(
    model::CTModels.ConstraintsModel
) -> Int64

Return the dimension of variable box constraints.

dim_variable_constraints_box(ocp::Model) -> Int64

Return the dimension of box constraints on variable.

dimension(model::CTModels.ControlModelSolution) -> Int64

Get the control dimension from the model solution.

dimension(model::CTModels.ControlModel) -> Int64

Get the control dimension from the model.

dimension(_::CTModels.EmptyVariableModel) -> Int64

Get the variable dimension from the empty variable model. Return 0.

dimension(model::CTModels.StateModelSolution) -> Int64

Get the dimension of the state from the state model solution.

dimension(model::CTModels.StateModel) -> Int64

Get the dimension of the state from the state model.

dimension(model::CTModels.VariableModelSolution) -> Int64

Get the variable dimension from the variable model solution.

dimension(model::CTModels.VariableModel) -> Int64

Get the variable dimension from the variable model.

dual(
    sol::CTModels.Solution,
    model::Model,
    label::Symbol
) -> Any

dual_model(
    sol::CTModels.Solution{<:CTModels.AbstractTimeGridModel, <:CTModels.AbstractTimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, <:Function, <:Real, DM<:CTModels.AbstractDualModel}
) -> CTModels.AbstractDualModel

dynamics!(ocp::CTModels.PreModel, f::Function)

Set the dynamics of the optimal control problem, in a pre-model.

dynamics(
    ocp::Model{<:CTModels.AbstractTimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, D<:Function}
) -> Function

Get the dynamics from the model.

export_ocp_solution(args...; format, kwargs...)

Export a solution in JLD or JSON formats.

Examples

julia> CTModels.export_ocp_solution(sol; filename="solution", format=:JSON)
julia> CTModels.export_ocp_solution(sol; filename="solution", format=:JLD)

export_ocp_solution(::CTModels.JLD2Tag, args...; kwargs...)

Export a solution in JLD format.

export_ocp_solution(::CTModels.JSON3Tag, args...; kwargs...)

Export a solution in JSON format.

final(
    model::CTModels.TimesModel{<:CTModels.AbstractTimeModel, TF<:CTModels.AbstractTimeModel}
) -> CTModels.AbstractTimeModel

Get the final time from the times model.

final_time(
    ocp::CTModels.AbstractModel,
    variable::AbstractVector
) -> Any

final_time(ocp::CTModels.AbstractModel) -> Real

final_time(
    model::CTModels.TimesModel{<:CTModels.AbstractTimeModel, <:CTModels.FixedTimeModel{T<:Real}}
) -> Real

Get the final time from the times model, from a fixed final time model.

final_time(
    ocp::Model{<:CTModels.TimesModel{<:CTModels.AbstractTimeModel, CTModels.FixedTimeModel{T<:Real}}}
) -> Real

Get the final time from the model, for a fixed final time.

final_time(
    model::CTModels.TimesModel{<:CTModels.AbstractTimeModel, CTModels.FreeTimeModel},
    variable::AbstractArray{T<:Real, 1}
) -> Any

Get the final time from the times model, from a free final time model.

final_time(
    ocp::Model{<:CTModels.TimesModel{<:CTModels.AbstractTimeModel, CTModels.FreeTimeModel}},
    variable::AbstractArray{T<:Real, 1}
) -> Any

Get the final time from the model, for a free final time.

final_time_name(sol::CTModels.Solution) -> String

Return the name of the final time of the optimal control solution.

final_time_name(model::CTModels.TimesModel) -> String

Get the name of the final time from the times model.

final_time_name(ocp::Model) -> String

Get the name of the final time from the model.

formatData(data) -> Any

Convert matrix to vector of vectors (could be expanded)

formatTimeGrid(time) -> Any

Convert matrix time-grid to vector

has_fixed_final_time(
    times::CTModels.TimesModel{<:CTModels.AbstractTimeModel, CTModels.FreeTimeModel}
) -> Bool

Check if the final time is free. Return false.

has_fixed_final_time(ocp::Model) -> Bool

Check if the final time is fixed.

has_fixed_final_time(
    times::CTModels.TimesModel{<:CTModels.AbstractTimeModel, <:CTModels.FixedTimeModel{T<:Real}}
) -> Bool

Check if the final time is fixed. Return true.

has_fixed_initial_time(
    times::CTModels.TimesModel{CTModels.FreeTimeModel}
) -> Bool

Check if the initial time is free. Return false.

has_fixed_initial_time(ocp::Model) -> Bool

Check if the initial time is fixed.

has_fixed_initial_time(
    times::CTModels.TimesModel{<:CTModels.FixedTimeModel{T<:Real}}
) -> Bool

Check if the initial time is fixed. Return true.

has_free_final_time(times::CTModels.TimesModel) -> Bool

Check if the final time is free.

has_free_final_time(ocp::Model) -> Bool

Check if the final time is free.

has_free_initial_time(times::CTModels.TimesModel) -> Bool

Check if the final time is free.

has_free_initial_time(ocp::Model) -> Bool

Check if the initial time is free.

has_lagrange_cost(
    model::CTModels.BolzaObjectiveModel
) -> Bool

Check if the Bolza objective model has a Lagrange function. Return true.

has_lagrange_cost(
    model::CTModels.LagrangeObjectiveModel
) -> Bool

Check if the Lagrange objective model has a Lagrange function. Return true.

has_lagrange_cost(
    model::CTModels.MayerObjectiveModel
) -> Bool

Check if the Mayer objective model has a Lagrange function. Return false.

has_lagrange_cost(ocp::Model) -> Bool

Check if the model has a Lagrange cost.

has_mayer_cost(model::CTModels.BolzaObjectiveModel) -> Bool

Check if the Bolza objective model has a Mayer function. Return true.

has_mayer_cost(
    model::CTModels.LagrangeObjectiveModel
) -> Bool

Check if the Lagrange objective model has a Mayer function. Return false.

has_mayer_cost(model::CTModels.MayerObjectiveModel) -> Bool

Check if the Mayer objective model has a Mayer function. Return true.

has_mayer_cost(ocp::Model) -> Bool

Check if the model has a Mayer cost.

import_ocp_solution(args...; format, kwargs...)

Import a solution from a JLD or JSON file.

Examples

julia> sol = CTModels.import_ocp_solution(ocp; filename="solution", format=:JSON)
julia> sol = CTModels.import_ocp_solution(ocp; filename="solution", format=:JLD)

import_ocp_solution(::CTModels.JLD2Tag, args...; kwargs...)

Import a solution from a JLD file.

import_ocp_solution(::CTModels.JSON3Tag, args...; kwargs...)

Import a solution from a JLD file.

index(model::CTModels.FreeTimeModel) -> Int64

Get the index of the time variable from the free time model.

infos(sol::CTModels.Solution) -> Dict{Symbol, Any}

Return a dictionary of additional infos depending on the solver or nothing.

initial(
    model::CTModels.TimesModel{TI<:CTModels.AbstractTimeModel}
) -> CTModels.AbstractTimeModel

Get the initial time from the times model.

initial_time(
    model::CTModels.TimesModel{<:CTModels.FixedTimeModel{T<:Real}}
) -> Real

Get the initial time from the times model, from a fixed initial time model.

initial_time(
    ocp::Model{<:CTModels.TimesModel{CTModels.FixedTimeModel{T<:Real}}}
) -> Real

Get the initial time from the model, for a fixed initial time.

initial_time(
    model::CTModels.TimesModel{CTModels.FreeTimeModel},
    variable::AbstractArray{T<:Real, 1}
) -> Any

Get the initial time from the times model, from a free initial time model.

initial_time(
    ocp::Model{<:CTModels.TimesModel{CTModels.FreeTimeModel}},
    variable::AbstractArray{T<:Real, 1}
) -> Any

Get the initial time from the model, for a free initial time.

initial_time_name(sol::CTModels.Solution) -> String

Return the name of the initial time of the optimal control solution.

initial_time_name(model::CTModels.TimesModel) -> String

Get the name of the initial time from the times model.

initial_time_name(ocp::Model) -> String

Get the name of the initial time from the model.

is_empty_time_grid(sol::CTModels.Solution) -> Bool

Check if the time grid is empty from the solution.

isaVectVect(data) -> Bool

Return true if argument is a vector of vectors

isempty_constraints(ocp::Model) -> Bool

Return true if the model has constraints or false if not.

iterations(sol::CTModels.Solution) -> Int64

Return the number of iterations (if solved by an iterative method) of the optimal control solution.

lagrange(
    model::CTModels.BolzaObjectiveModel{<:Function, L<:Function}
) -> Function

Get the Lagrange function of the Bolza objective model.

lagrange(
    model::CTModels.LagrangeObjectiveModel{L<:Function}
) -> Function

Get the Lagrange function of the Lagrange objective model.

lagrange(
    ocp::Model{<:CTModels.AbstractTimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, <:Function, <:CTModels.BolzaObjectiveModel{<:Function, L<:Function}}
) -> Any

Get the Lagrange cost from the model.

lagrange(
    ocp::Model{<:CTModels.AbstractTimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, <:Function, CTModels.LagrangeObjectiveModel{L<:Function}}
) -> Function

Get the Lagrange cost from the model.

matrix2vec(A::Matrix{<:Real}) -> Vector{<:Vector{<:Real}}
matrix2vec(
    A::Matrix{<:Real},
    dim::Int64
) -> Vector{<:Vector{<:Real}}

Transforms A to a Vector{<:Vector{<:ctNumber}}.

Note. dim ∈ {1, 2} is the dimension along which the matrix is transformed.

mayer(
    model::CTModels.BolzaObjectiveModel{M<:Function}
) -> Function

Get the Mayer function of the Bolza objective model.

mayer(
    model::CTModels.MayerObjectiveModel{M<:Function}
) -> Function

Get the Mayer function of the Mayer objective model.

mayer(
    ocp::Model{<:CTModels.AbstractTimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, <:Function, <:CTModels.BolzaObjectiveModel{M<:Function}}
) -> Any

Get the Mayer cost from the model.

mayer(
    ocp::Model{<:CTModels.AbstractTimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, <:Function, <:CTModels.MayerObjectiveModel{M<:Function}}
) -> Any

Get the Mayer cost from the model.

message(sol::CTModels.Solution) -> String

Return the message associated to the stopping criterion of the optimal control solution.

name(model::CTModels.ControlModelSolution) -> String

Get the name of the control from the model solution.

name(model::CTModels.ControlModel) -> String

Get the name of the control from the model.

name(_::CTModels.EmptyVariableModel) -> String

Get the variable name from the empty variable model. Return an empty string.

name(model::CTModels.FixedTimeModel) -> String

Get the name of the time from the fixed time model.

name(model::CTModels.FreeTimeModel) -> String

Get the name of the time from the free time model.

name(model::CTModels.StateModelSolution) -> String

Get the name of the state from the state model solution.

name(model::CTModels.StateModel) -> String

Get the name of the state from the state model.

name(model::CTModels.VariableModelSolution) -> String

Get the variable name from the variable model solution.

name(model::CTModels.VariableModel) -> String

Get the variable name from the variable model.

objective!(ocp::CTModels.PreModel; ...)
objective!(
    ocp::CTModels.PreModel,
    criterion::Symbol;
    mayer,
    lagrange
)

Set the objective of the optimal control problem.

Arguments

• ocp::PreModel: the optimal control problem.
• criterion::Symbol: the type of criterion. Either :min or :max. Default is :min.
• mayer::Union{Function, Nothing}: the Mayer function (inplace). Default is nothing.
• lagrange::Union{Function, Nothing}: the Lagrange function (inplace). Default is nothing.

Examples

```@example julia> function mayer(x0, xf, v) return x0[1] + xf[1] + v[1] end juila> function lagrange(t, x, u, v) return x[1] + u[1] + v[1] end julia> objective!(ocp, :min, mayer=mayer, lagrange=lagrange)

objective(
    sol::CTModels.Solution{<:CTModels.AbstractTimeGridModel, <:CTModels.AbstractTimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, <:Function, O<:Real}
) -> Real

Return the objective value of the optimal control solution.

objective(
    ocp::Model{<:CTModels.AbstractTimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, <:Function, O<:CTModels.AbstractObjectiveModel}
) -> CTModels.AbstractObjectiveModel

Get the objective from the model.

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

Return the dual of the path constraints of the optimal control solution.

path_constraints_dual(
    model::CTModels.DualModel{PC_Dual<:Union{Nothing, Function}}
) -> Union{Nothing, Function}

path_constraints_nl(
    model::CTModels.ConstraintsModel{TP}
) -> Any

Get the nonlinear path constraints from the model.

path_constraints_nl(
    ocp::Model{<:CTModels.TimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, <:Function, <:CTModels.AbstractObjectiveModel, <:CTModels.ConstraintsModel{TP<:Tuple}}
) -> Any

Get the nonlinear path constraints from the model.

state!(ocp::CTModels.PreModel, n::Int64)
state!(
    ocp::CTModels.PreModel,
    n::Int64,
    name::Union{String, Symbol}
)
state!(
    ocp::CTModels.PreModel,
    n::Int64,
    name::Union{String, Symbol},
    components_names::Array{T2<:Union{String, Symbol}, 1}
)

Define the state dimension and possibly the names of each component.

Examples

julia> state!(ocp, 1)
julia> state_dimension(ocp)
1
julia> state_components(ocp)
["x"]

julia> state!(ocp, 1, "y")
julia> state_dimension(ocp)
1
julia> state_components(ocp)
["y"]

julia> state!(ocp, 2)
julia> state_dimension(ocp)
2
julia> state_components(ocp)
["x₁", "x₂"]

julia> state!(ocp, 2, :y)
julia> state_dimension(ocp)
2
julia> state_components(ocp)
["y₁", "y₂"]

julia> state!(ocp, 2, "y")
julia> state_dimension(ocp)
2
julia> state_components(ocp)
["y₁", "y₂"]

julia> state!(ocp, 2, "y", ["u", "v"])
julia> state_dimension(ocp)
2
julia> state_components(ocp)
["u", "v"]

julia> state!(ocp, 2, "y", [:u, :v])
julia> state_dimension(ocp)
2
julia> state_components(ocp)
["u", "v"]

state(
    sol::CTModels.Solution{<:CTModels.AbstractTimeGridModel, <:CTModels.AbstractTimesModel, <:CTModels.StateModelSolution{TS<:Function}}
) -> Function

Return the state (function of time) of the optimal control solution.

julia> t0 = time_grid(sol)[1]
julia> x  = state(sol)
julia> x0 = x(t0)

state(
    ocp::Model{<:CTModels.TimesModel, T<:CTModels.AbstractStateModel}
) -> CTModels.AbstractStateModel

Get the state from the model.

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

Return the names of the components of the state of the optimal control solution.

state_components(ocp::Model) -> Vector{String}

Get the components names of the state from the model.

state_constraints_box(
    model::CTModels.ConstraintsModel{<:Tuple, <:Tuple, TS}
) -> Any

Get the state box constraints from the model.

state_constraints_box(
    ocp::Model{<:CTModels.TimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, <:Function, <:CTModels.AbstractObjectiveModel, <:CTModels.ConstraintsModel{<:Tuple, <:Tuple, TS<:Tuple}}
) -> Any

Get the box constraints on state from the model.

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

Return the lower bound dual of the state constraints of the optimal control solution.

state_constraints_lb_dual(
    model::CTModels.DualModel{<:Union{Nothing, Function}, <:Union{Nothing, AbstractVector{<:Real}}, SC_LB_Dual<:Union{Nothing, Function}}
) -> Union{Nothing, Function}

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

Return the upper bound dual of the state constraints of the optimal control solution.

state_constraints_ub_dual(
    model::CTModels.DualModel{<:Union{Nothing, Function}, <:Union{Nothing, AbstractVector{<:Real}}, <:Union{Nothing, Function}, SC_UB_Dual<:Union{Nothing, Function}}
) -> Union{Nothing, Function}

state_dimension(sol::CTModels.Solution) -> Int64

Return the dimension of the state of the optimal control solution.

state_dimension(ocp::Model) -> Int64

Get the state dimension from the model.

state_name(sol::CTModels.Solution) -> String

Return the name of the state of the optimal control solution.

state_name(ocp::Model) -> String

Get the name of the state from the model.

stopping(sol::CTModels.Solution) -> Symbol

Return the stopping criterion (a Symbol) of the optimal control solution.

success(sol::CTModels.Solution) -> Bool

Return the success status of the optimal control solution.

time!(ocp::CTModels.PreModel; t0, tf, ind0, indf, time_name)

Set the initial and final times. We denote by t0 the initial time and tf the final time. The optimal control problem is denoted ocp. When a time is free, then, one must provide the corresponding index of the ocp variable.

Examples

julia> time!(ocp, t0=0,   tf=1  ) # Fixed t0 and fixed tf
julia> time!(ocp, t0=0,   indf=2) # Fixed t0 and free  tf
julia> time!(ocp, ind0=2, tf=1  ) # Free  t0 and fixed tf
julia> time!(ocp, ind0=2, indf=3) # Free  t0 and free  tf

When you plot a solution of an optimal control problem, the name of the time variable appears. By default, the name is "t". Consider you want to set the name of the time variable to "s".

julia> time!(ocp, t0=0, tf=1, time_name="s") # time_name is a String
# or
julia> time!(ocp, t0=0, tf=1, time_name=:s ) # time_name is a Symbol  

time(model::CTModels.FixedTimeModel{T<:Real}) -> Real

Get the time from the fixed time model.

time(
    model::CTModels.FreeTimeModel,
    variable::AbstractArray{T<:Real, 1}
) -> Any

Get the time from the free time model.

Exceptions

• If the index of the time variable is not in [1, length(variable)], throw an error.

time_grid(
    sol::CTModels.Solution{<:CTModels.TimeGridModel{T<:Union{StepRangeLen, AbstractVector{<:Real}}}}
) -> Union{StepRangeLen, AbstractVector{<:Real}}

Return the time grid of the optimal control solution.

time_name(sol::CTModels.Solution) -> String

Return the name of the time component of the optimal control solution.

time_name(model::CTModels.TimesModel) -> String

Get the name of the time variable from the times model.

time_name(ocp::Model) -> String

Get the name of the time from the model.

times(
    ocp::Model{T<:CTModels.TimesModel}
) -> CTModels.TimesModel

Get the times from the model.

to_out_of_place(
    f!,
    n;
    T
) -> Union{Nothing, CTModels.var"#f#19"{CTModels.var"#f#18#20"{DataType, _A, _B}} where {_A, _B}}

Transform an in-place function f! to an out-of-place function f. The function f will return a vector of the same type as T and size n.

value(
    model::CTModels.ControlModelSolution{TS<:Function}
) -> Function

Get the control function value from the model solution.

value(
    model::CTModels.StateModelSolution{TS<:Function}
) -> Function

Get the state function from the state model solution.

value(
    model::CTModels.VariableModelSolution{TS<:Union{Real, AbstractVector{<:Real}}}
) -> Union{Real, AbstractVector{<:Real}}

Get the variable from the variable model solution.

variable!(ocp::CTModels.PreModel, q::Int64)
variable!(
    ocp::CTModels.PreModel,
    q::Int64,
    name::Union{String, Symbol}
)
variable!(
    ocp::CTModels.PreModel,
    q::Int64,
    name::Union{String, Symbol},
    components_names::Array{T2<:Union{String, Symbol}, 1}
)

Define the variable dimension and possibly the names of each component.

Examples

julia> variable!(ocp, 1, "v")
julia> variable!(ocp, 2, "v", [ "v₁", "v₂" ])

variable(
    sol::CTModels.Solution{<:CTModels.AbstractTimeGridModel, <:CTModels.AbstractTimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.VariableModelSolution{TS<:Union{Real, AbstractVector{<:Real}}}}
) -> Union{Real, AbstractVector{<:Real}}

Return the variable of the optimal control solution or nothing.

julia> v  = variable(sol)

variable(
    ocp::Model{<:CTModels.TimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, T<:CTModels.AbstractVariableModel}
) -> CTModels.AbstractVariableModel

Get the variable from the model.

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

Return the names of the components of the variable of the optimal control solution.

variable_components(ocp::Model) -> Vector{String}

Get the components names of the variable from the model.

variable_constraints_box(
    model::CTModels.ConstraintsModel{<:Tuple, <:Tuple, <:Tuple, <:Tuple, TV}
) -> Any

Get the variable box constraints from the model.

variable_constraints_box(
    ocp::Model{<:CTModels.TimesModel, <:CTModels.AbstractStateModel, <:CTModels.AbstractControlModel, <:CTModels.AbstractVariableModel, <:Function, <:CTModels.AbstractObjectiveModel, <:CTModels.ConstraintsModel{<:Tuple, <:Tuple, <:Tuple, <:Tuple, TV<:Tuple}}
) -> Any

Get the box constraints on variable from the model.

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

Return the lower bound dual of the variable constraints of the optimal control solution.

variable_constraints_lb_dual(
    model::CTModels.DualModel{<:Union{Nothing, Function}, <:Union{Nothing, AbstractVector{<:Real}}, <:Union{Nothing, Function}, <:Union{Nothing, Function}, <:Union{Nothing, Function}, <:Union{Nothing, Function}, VC_LB_Dual<:Union{Nothing, AbstractVector{<:Real}}}
) -> Union{Nothing, AbstractVector{<:Real}}

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

Return the upper bound dual of the variable constraints of the optimal control solution.

variable_constraints_ub_dual(
    model::CTModels.DualModel{<:Union{Nothing, Function}, <:Union{Nothing, AbstractVector{<:Real}}, <:Union{Nothing, Function}, <:Union{Nothing, Function}, <:Union{Nothing, Function}, <:Union{Nothing, Function}, <:Union{Nothing, AbstractVector{<:Real}}, VC_UB_Dual<:Union{Nothing, AbstractVector{<:Real}}}
) -> Union{Nothing, AbstractVector{<:Real}}

variable_dimension(sol::CTModels.Solution) -> Int64

Return the dimension of the variable of the optimal control solution.

variable_dimension(ocp::Model) -> Int64

Get the variable dimension from the model.

variable_name(sol::CTModels.Solution) -> String

Return the name of the variable of the optimal control solution.

variable_name(ocp::Model) -> String

Get the name of the variable from the model.