Future: declaration of time, state, control and variable in the abstract syntax

[ocots]

The idea of this issue is to add possibilities of declaration of time, state, control and variable.

For instance, this current declaration

@def begin
    tf ∈ R, variable
    t ∈ [0, tf], time
    x = (q, v) ∈ R², state
    u ∈ R, control
    tf ≥ 0 
    v(t) ≤ 1
    -1 ≤ u(t) ≤ 1
end

must be equivalent to

@def begin
    tf ∈ R₊, variable
    t ∈ [0, tf], time
    x = (q, v) ∈ (-∞, 1] × R, state
    u ∈ [-1, 1], control
end

In the comments below, you will find:

• Preliminaries: how the code works.
• Current possibilities: how to declare for the moment.
• Todo: the new possibilities.

[ocots]

Preliminaries

To define an optimal control problem with the abstract syntax, one must use the @def macro:

CTBase.jl/src/onepass.jl

Line 504 in e77f83a

macro def(e)

The key internal function is the one which in one pass parse the code:

CTBase.jl/src/onepass.jl

Line 75 in e77f83a

parse!(p, ocp, e; log=false) = begin

Every line of the code is parsed to in order to call the right functional method to construct the model of OptimalControlModel type of the optimal control problem.

For instance,

ocp = @def t ∈ [0, 1], time

is transformed into

time!(ocp, t0=0, tf=1)

from

CTBase.jl/src/optimal_control_model-setters.jl

Line 329 in e77f83a

function time!(

thanks to the internal function p_time!. See

CTBase.jl/src/onepass.jl

Line 99 in e77f83a

:( $t ∈ [ $t0, $tf ], time ) => p_time!(p, ocp, t, t0, tf; log)

and

CTBase.jl/src/onepass.jl

Line 201 in e77f83a

p_time!(p, ocp, t, t0, tf; log=false) = begin

[ocots]

Current possibilities

Variable

In order to declare a variable we have:

:( $v ∈ R^$q, variable ) 
:( $v ∈ R   , variable ) 

Example.

@def begin
    v ∈ R², variable
end

Aliases v₁, v₂ (and v1, v2) are automatically defined and can be used in subsequent expressions instead of v[1] and v[2]. The user can also define her own aliases for the components (one alias per dimension):

@def begin
    v = (a, b) ∈ R², variable
end

A one dimensional variable can be declared according to

@def begin
    v ∈ R, variable
end

Time

In order to declare the time we have:

:( $t ∈ [$t0, $tf], time ) 

The independent variable or time is a scalar bound to a given interval. Its name is arbitrary.

t0 = 1
tf = 5
@def begin
    t ∈ [t0, tf], time
end

One (or even the two bounds) can be variable, typically for minimum time problems (see Mayer cost section):

@def begin
    v = (T, λ) ∈ R², variable
    t ∈ [0, T], time
end

State

:( $x ∈ R^$n, state ) 
:( $x ∈ R   , state ) 

The state declaration defines the name and the dimension of the state:

@def begin
    x ∈ R⁴, state
end

As for the variable, there are automatic aliases (x₁ and x1 for x[1], etc.) and the user can define her own aliases (one per scalar component of the state):

@def begin
    x = (q₁, q₂, v₁, v₂) ∈ R⁴, state
end

Control

:( $u ∈ R^$m, control ) 
:( $u ∈ R   , control ) 

The control declaration defines the name and the dimension of the control:

@def begin
    u ∈ R², control
end

As before, there are automatic aliases (u₁ and u1 for u[1], etc.) and the user can define her own aliases (one per scalar component of the state):

@def begin
    u = (α, β) ∈ R², control
end

Constraints

:( $e1 == $e2        ) 
:( $e1 ≤  $e2 ≤  $e3 ) 
:(        $e2 ≤  $e3 ) 
:( $e3 ≥  $e2 ≥  $e1 ) 
:( $e2 ≥  $e1        ) 

Admissible constraints can be

• five types: boundary, control, state, mixed, variable,
• linear (ranges) or nonlinear (not ranges),
• equalities or (one or two-sided) inequalities.

Boundary conditions are detected when the expression contains evaluations of the state at initial and / or final time bounds (e.g., x(0)), and may not involve the control. Conversely control, state or mixed constraints will involve control, state or both evaluated at the declared time (e.g., x(t) + u(t)).
Other combinations should be detected as incorrect by the parser 🤞🏾. The variable may be involved in any of the four previous constraints. Constraints involving the variable only are variable constraints, either linear or nonlinear.
In the example below, there are

• two linear boundary constraints,
• one linear variable constraint,
• one linear state constraint,
• one (two-sided) nonlinear control constraint.

@def begin
    tf ∈ R, variable
    t ∈ [0, tf], time
    x ∈ R², state
    u ∈ R, control
    x(0) == [-1, 0]
    x(tf) == [0, 0]
    ẋ(t) == [x₂(t), u(t)]
    tf ≥ 0 
    x₂(t) ≤ 1
    u(t)^2 ≤ 1
end

Note

Symbols like <= or >= are also authorised:

[ocots]

Todo

To declare the time, state, control and variable, I propose the following possibilities:

@def begin
  t ∈ [ 0, 1 ], time
  x ∈ R³, state
  u ∈ R², control
end

# or

@def begin
  (t, x, u) ∈ [ 0, 1 ] × R³ × R²
end

@def begin
  v ∈ R², variable
  t ∈ [ 0, v₂ ], time
  x ∈ R³, state
  u ∈ R², control
end

# or

@def begin
  (t, x, u, v) ∈ [ 0, v₂ ] × R³ × R² × R²
end

@def begin
  t ∈ [ 0, 1 ], time
  x = (a, b, c) ∈ R³, state
  u ∈ R², control
  u₁(t) ≥ 0
  0 ≤ c(t) ≤ 1
end

# or

@def begin
  t ∈ [ 0, 1 ], time
  x = (a, b, c) ∈ R² × [ 0, 1 ] , state
  u ∈ R₊ × R, control
end

# or

@def begin
  t ∈ [ 0, 1 ], time
  x = (a, b, c) ∈ R × R × [ 0, 1 ] , state
  u ∈ [ 0, +∞) × R, control
end

[ocots]

Need also to add: R₋ = (-∞, 0].

[jbcaillau]

@ocots not a big fan of everything in the same line as in

  (t, x, u, v) ∈ [ 0, v₂ ] × R³ × R² × R²

and not at all top priority I would say... but: if you want it, add it 🙂!