IR for abstract description

[jbcaillau]

Could be interesting to use the functional description (see description below, still needs to be documented) as an IR (= intermediate representation) for the abstract description (see also below):

• ongoing work (@j-l-s) is to translate an abstract description into an ocp, de facto using calls to the functional description
• so it is rather simple to compile an abstract description into a functional one
• doing so, someone else might want to use the functional description of an ocp (rather than the type itself) to reimplement her own primitives (constraint...)

# Time
t ∈ [ t0, tf ], time

tf ∈ R, variable
t ∈ [ t0, tf ], time

t0 ∈ R, variable
t ∈ [ t0, tf ], time

time!(ocp, [t0, tf])
time!(ocp, :initial, t0)
time!(ocp, :final, tf)

# States
x ∈ R^n, state

state!(ocp, n)

# Controls
u ∈ R^m, control

control!(ocp, m)

# Variables
y ∈ R^p, variable

variable!(ocp, p)

# Initial constraints
x(t0) == x0
x0_b ≤ x(t0) ≤ x0_u
x[2:3](t0) == y0
y0_b ≤ x[2:3](t0) ≤ y0_u
x[2](t0)^2 == 1
1 ≤ x[2](t0)^2 ≤ 2
1 ≤ x[2](t0)^2 ≤ 2, (1)

constraint!(ocp, :initial, x0)
constraint!(ocp, :initial, x0_b, x0_u)
constraint!(ocp, :initial, 2:3, y0)
constraint!(ocp, :initial, 2:3, y0_b, y0_u)
constraint!(ocp, :initial, x0 -> x0[2]^2, 1)
constraint!(ocp, :initial, x0 -> x0[2]^2, 1, 2)
constraint!(ocp, :initial, x0 -> x0[2]^2, 1, 2, :eq1)

# Final constraints 
x(tf) == xf
xf_b ≤ x(tf) ≤ xf_u
x[2:3](tf) == yf
yf_b ≤ x[2:3](tf) ≤ yf_u
x[2](tf)^2 == 1
1 ≤ x[2](tf)^2 ≤ 2
1 ≤ x[2](tf)^2 ≤ 2, (1)

constraint!(ocp, :final, xf)
constraint!(ocp, :final, xf_b, xf_u)
constraint!(ocp, :final, 2:3, yf)
constraint!(ocp, :final, 2:3, yf_b, yf_u)
constraint!(ocp, :final, xf -> xf[2]^2, 1)
constraint!(ocp, :final, xf -> xf[2]^2, 1, 2)
constraint!(ocp, :final, xf -> xf[2]^2, 1, 2, :eq1)

# Boundary constraints
x(tf) - tf*x(t0) == [ 0, 1 ]
[ 0, 1 ] ≤ x(tf) - tf*x(t0) ≤ [ 1, 3 ]
[ 0, 1 ] ≤ x(tf) - tf*x(t0) ≤ [ 1, 3 ], (1)

constraint!(ocp, :boundary, (t0, x0, tf, xf) -> xf - tf*x0, [ 0, 1 ])
constraint!(ocp, :boundary, (t0, x0, tf, xf) -> xf - tf*x0, [ 0, 1 ], [ 1, 3 ])
constraint!(ocp, :boundary, (t0, x0, tf, xf) -> xf - tf*x0, [ 0, 1 ], [ 1, 3 ], :eq1)

# Control constraints
u_b ≤ u(t) ≤ u_u
v_b ≤ u[2:3](t) ≤ v_u
u[1](t)^2 + u[2](t)^2 == 1
1 ≤ u[1](t)^2 + u[2](t)^2 ≤ 2
1 ≤ u[1](t)^2 + u[2](t)^2 ≤ 2, (1)

constraint!(ocp, :control, u_b, u_u)
constraint!(ocp, :control, 2:3, v_b, v_u)
constraint!(ocp, :control, u -> u[1]^2 + u[2]^2, 1)
constraint!(ocp, :control, u -> u[1]^2 + u[2]^2, 1, 2)
constraint!(ocp, :control, u -> u[1]^2 + u[2]^2, 1, 2, :eq1)

# State constraints
x_b ≤ x(t) ≤ x_u
y_b ≤ x[2:3](t) ≤ y_u
x[1:2](t) + x[3:4](t) == [ -1, 1 ]
[ -1, 1 ] ≤ x[1:2](t) + x[3:4](t) ≤ [ 0, 2 ]
[ -1, 1 ] ≤ x[1:2](t) + x[3:4](t) ≤ [ 0, 2 ], (1)

constraint!(ocp, :state, x_b, x_u)
constraint!(ocp, :state, 2:3, y_b, y_u)
constraint!(ocp, :state, x -> x[1:2] + x[3:4], [ -1, 1 ])
constraint!(ocp, :state, x -> x[1:2] + x[3:4], [ -1, 1 ], [ 0, 2 ])
constraint!(ocp, :state, x -> x[1:2] + x[3:4], [ -1, 1 ], [ 0, 2 ], :eq1)

# Mixed constraints
u[2](t) * x[1:2](t) == [ -1, 1 ]
[ -1, 1 ] ≤ u[2](t) * x[1:2](t) ≤ [ 0, 2 ]
[ -1, 1 ] ≤ u[2](t) * x[1:2](t) ≤ [ 0, 2 ], (1)

constraint!(ocp, :mixed, (x, u) -> u[2] * x[1:2], [ -1, 1 ])
constraint!(ocp, :mixed, (x, u) -> u[2] * x[1:2], [ -1, 1 ], [ 0, 2 ])
constraint!(ocp, :mixed, (x, u) -> u[2] * x[1:2], [ -1, 1 ], [ 0, 2 ], :eq1)

# Dynamics
ẋ(t) == f(x(t), u(t))
f!(ẋ(t), x(t), u(t))

constraint!(ocp, :dynamics, f)
constraint!(ocp, :dynamics!, f!)

# Objective
x₁(tf) → max
∫ ( x₂(t)^2 + u₁(t)^2 ) → min
-x₁(tf) + ∫ ( x₂(t)^2 + u₁(t)^2 ) → min

objective!(ocp, :mayer, (t0, x0, tf, xf) -> xf[1], :max)
objective!(ocp, :lagrange, (x, u) -> x[2]^2 + u[1]^2, :min)
objective!(ocp, :bolza, (t0, x0, tf, xf) -> -xf[1], (x, u) -> x[2]^2 + u[1]^2, :min)

[ocots]

Note that I have introduced some labels for the state and the control. For the moment, the labels are set at the same time than the dimensions, but this can be updated (meaning not replacing the functions but adding another one).

function state!(ocp::OptimalControlModel, n::Dimension; labels::Vector{String}=_state_labels(n))
    ocp.state_dimension = n
    ocp.state_labels = labels
end

function control!(ocp::OptimalControlModel, m::Dimension; labels::Vector{String}=_control_labels(m))
    ocp.control_dimension = m
    ocp.control_labels = labels
end

The default values are $x_1, \cdots, x_n$ for the state and $u_1, \cdots, u_m$ for the control.

ctindice(i::Integer) = '\u2080' + i
function ctindices(i::Integer)
    s=""
    for d ∈ digits(i)
        s = ctindice(d) * s
    end
    return s
end
_state_labels(n::Dimension) = n==1 ? ["x"] : [ "x" * ctindices(i) for i ∈ range(1, n)]
_control_labels(m::Dimension) = m==1 ? ["u"] : [ "u" * ctindices(i) for i ∈ range(1, m)]

[jbcaillau]

very good:

• in the abstract description, state and control must have a name; the info has to be taken into account when translating towards the functional description
• as you have put default values, no strict API change 👍🏽
• just used for plots right now, right?

[ocots]

Yes just for plots. It is indeed simply plots labels.

[ocots]

For the adjoint vector, I simply concatenate p with the state labels.

[ocots]

Actually, it would be possible to write some Latex instead of Unicode.

[jbcaillau]

@ocots NB. Do the same for time! as the independent variable can (is in abstract format) be named, so the name can be used for xlabel.

[ocots]

For xlabel or we could write u(t) in the label. What do you prefer?

[jbcaillau]

just $u$?

[ocots]

Question: do you want me to create a new Github repository for the parser? I can create CTParser.jl for instance. It could either import CTBase or the contrary. Maybe it could import CTBase and use the Model description and the Functional usage to define a Model from an Expr.

[jbcaillau]

Seing @j-l-s Thursday on this, coming back to you then.

PS. Yes, it is just transforming an Expr into an OptimalControlModel