Problem

struct Problem{Q<:RobotDynamics.QuadratureRule, T<:AbstractFloat}

Trajectory Optimization Problem. Contains the full definition of a trajectory optimization problem, including:

• dynamics model (Model)
• objective (Objective)
• constraints (ConstraintSet)
• initial and final states
• Primal variables (state and control trajectories)
• Discretization information: knot points (N), time step (dt), and total time (tf)

Constructors:

Problem(model, obj, constraints, x0, xf, Z, N, tf) # defaults to RK3 integration
Problem{Q}(model, obj, constraints, x0, xf, Z, N, tf) where Q<:QuadratureRule
Problem(model, obj, xf, tf; x0, constraints, N, X0, U0, dt, integration)
Problem{Q}(prob::Problem)  # change integration

where Z is a trajectory (Vector of KnotPoints)

Arguments

• model: Dynamics model. Can be either Discrete or Continuous
• obj: Objective
• X0: Initial state trajectory. If omitted it will be initialized with NaNs, to be later overwritten by the solver.
• U0: Initial control trajectory. If omitted it will be initialized with zeros.
• x0: Initial state. Defaults to zeros.
• xf: Final state. Defaults to zeros.
• dt: Time step
• tf: Final time. Set to zero to specify a time penalized problem.
• N: Number of knot points. Defaults to 51, unless specified by dt and tf.
• integration: One of the defined integration types to discretize the continuous dynamics model.

Both X0 and U0 can be either a Matrix or a Vector{Vector}, but must be the same. At least 2 of dt, tf, and N need to be specified (or just 1 of dt and tf).

cost(::Problem)

Compute the cost for the current trajectory

states(::Problem)

Get the state trajectory.

controls(::Problem)

Get the control trajectory

size(prob::Problem) -> Tuple{Any,Any,Int64}

Get number of states, controls, and knot points

Get the number of constraint values at each time step

Get problem constraints. Returns AbstractConstraintSet.

Get the dynamics model. Returns RobotDynamics.AbstractModel.

Get the trajectory. Returns an RobotDynamics.AbstractTrajectory

Get the in initial state. Returns an AbstractVector.

get_times(::Problem)

Get the times for all the knot points in the problem.

integration(::Problem)
integration(::DynamicsConstraint)

Get the integration rule

Determines if the problem is constrained.

initial_controls!(::Problem, U0::Vector{<:AbstractVector})
initial_controls!(::Problem, U0::AbstractMatrx)

Copy the control trajectory

initial_states!(::Problem, X0::Vector{<:AbstractVector})
initial_states!(::Problem, X0::AbstractMatrix)

Copy the state trajectory

initial_trajectory!(prob::Problem, Z)

Copy the trajectory

set_initial_state!(prob::Problem, x0::AbstractVector)

Set the initial state in prob to x0

set_initial_time!(prob, t0)

Set the initial time of the optimization problem, shifting the time of all points in the trajectory. Returns the updated final time.

set_goal_state!(prob::Problem, xf::AbstractVector; objective=true, constraint=true)

Change the goal state. If the appropriate flags are true, it will also modify a GoalConstraint and the objective, assuming it's an LQRObjective.

change_integration(prob::Problem, Q<:QuadratureRule)

Change dynamics integration for the problem. Returns a new problem.

rollout!(::Problem)

Simulate the dynamics forward from the initial condition x0 using the controls in the trajectory Z. If a problem is passed in, Z = prob.Z, model = prob.model, and x0 = prob.x0.

Copy the problem