foo

Author: ocots

docs/Project.toml

@@ -1,2 +1,3 @@
 [deps]
-Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
+Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
+OptimalControl = "5f98b655-cc9a-415a-b60e-744165666948"

docs/make.jl

@@ -6,7 +6,7 @@ makedocs(
     format = Documenter.HTML(prettyurls = false),
     pages = [
         "Introduction" => "index.md",
-        "Tutorials" => "tutorials.md",
+        "Tutorials" => ["basic-example.md", "goddard.md"],
         "API" => "api.md",
         "Developpers" => "dev-api.md"
     ]

docs/src/basic-example.md

@@ -0,0 +1,60 @@
+# Basic example
+
+Consider we want to minimise the cost functional
+
+```math
+    \frac{1}{2}\int_{0}^{1} u^2(t) \, \mathrm{d}t
+```
+
+subject to the dynamical constraints for $t \in [0, 1]$
+
+```math
+    \dot x_1(t) = x_2(t), \quad \dot x_2(t) = u(t) \in \mathbb{R},
+```
+
+and the limit conditions
+
+```math
+    x(0) = (-1, 0), \quad x(1) = (0, 0).
+```
+
+First, we need to import the `OptimalControl.jl` package:
+
+```@example main
+using OptimalControl
+```
+
+Then, we can define the problem
+
+```@example main
+t0 = 0
+tf = 1
+A = [ 0 1
+      0 0 ]
+B = [ 0
+      1 ]
+
+@def ocp_di begin
+    t ∈ [ t0, tf ], time                         # time interval
+    x ∈ R², state                                # state
+    u ∈ R, control                               # control
+    x(t0) == [-1, 0],    (initial_con)           # initial condition
+    x(tf) == [0, 0],    (final_con)              # final condition
+    ẋ(t) == A * x(t) + B * u(t)                  # dynamics
+    ∫( 0.5u(t)^2 ) → min                         # objective
+end
+nothing # hide
+```
+
+Solve it
+
+```@example main
+sol_di = solve(ocp_di)
+nothing # hide
+```
+
+and plot the solution
+
+```@example main
+plot(sol_di, size=(700, 700))
+```

docs/src/tutorials.md renamed to docs/src/goddard.md

@@ -1,71 +1,6 @@
-# Tutorials
+# Advanced example
 
-## Basic example : double integrator
-
-Consider we want to minimise the cost functional
-
-```math
-    \frac{1}{2}\int_{0}^{1} u^2(t) \, \mathrm{d}t
-```
-
-subject to the dynamical constraints for $t \in [0, 1]$
-
-```math
-    \dot x_1(t) = x_2(t), \quad \dot x_2(t) = u(t) \in \mathbb{R},
-```
-
-and the limit conditions
-
-```math
-    x(0) = (-1, 0), \quad x(1) = (0, 0).
-```
-
-First, we need to import the `OptimalControl.jl` package:
-
-```@example main
-using OptimalControl
-```
-
-Then, we can define the problem
-
-```@example main
-t0 = 0
-tf = 1
-A = [ 0 1
-      0 0 ]
-B = [ 0
-      1 ]
-
-@def ocp_di begin
-    t ∈ [ t0, tf ], time                         # time interval
-    x ∈ R², state                                # state
-    u ∈ R, control                               # control
-    x(t0) == [-1, 0],    (initial_con)           # initial condition
-    x(tf) == [0, 0],    (final_con)              # final condition
-    ẋ(t) == A * x(t) + B * u(t)                  # dynamics
-    ∫( 0.5u(t)^2 ) → min                         # objective
-end
-nothing # hide
-```
-
-Solve it
-
-```@example main
-sol_di = solve(ocp_di)
-nothing # hide
-```
-
-and plot the solution
-
-```@example main
-plot(sol_di, size=(700, 700))
-```
-
-## Advanced example : Goddard
-
-This well-known problem[^1] [^2] models the ascent of a rocket through the atmosphere, and we restrict here ourselves to vertical (one dimensional) trajectories.
-The state variables are the altitude $r$, speed $v$ and mass $m$ of the rocket during the flight, for a total dimension of 3. 
-The rocket is subject to gravity $g$, thrust $u$ and drag force $D$ (function of speed and altitude). The final time $T$ is free, and the objective is to reach a maximal altitude with a bounded fuel consumption.
+This well-known problem[^1] [^2] models the ascent of a rocket through the atmosphere, and we restrict here ourselves to vertical (one dimensional) trajectories. The state variables are the altitude $r$, speed $v$ and mass $m$ of the rocket during the flight, for a total dimension of 3. The rocket is subject to gravity $g$, thrust $u$ and drag force $D$ (function of speed and altitude). The final time $T$ is free, and the objective is to reach a maximal altitude with a bounded fuel consumption.
 
 We thus want to solve the optimal control problem in Mayer form
 
@@ -86,7 +21,8 @@ $v(t) \leq v_{\max}$. The initial state is fixed while only the final mass is pr
 
 !!! note
 
-    The Hamiltonian is affine with respect to the control, so singular arcs may occur, as well as constrained arcs due to the path constraint on the velocity (see below).
+    The Hamiltonian is affine with respect to the control, so singular arcs may occur, 
+    as well as constrained arcs due to the path constraint on the velocity (see below).
 
 We import the `OptimalControl.jl` package:
 
@@ -166,4 +102,4 @@ plot(direct_sol_goddard, size=(700, 700))
 
 [^1]: R.H. Goddard. A Method of Reaching Extreme Altitudes, volume 71(2) of Smithsonian Miscellaneous Collections. Smithsonian institution, City of Washington, 1919.
 
-[^2]: H. Seywald and E.M. Cliff. Goddard problem in presence of a dynamic pressure limit. Journal of Guidance, Control, and Dynamics, 16(4):776–781, 1993.
+[^2]: H. Seywald and E.M. Cliff. Goddard problem in presence of a dynamic pressure limit. Journal of Guidance, Control, and Dynamics, 16(4):776–781, 1993.

docs/src/index.md

@@ -1,6 +1,17 @@
-# Introduction to the OptimalControl.jl package
+# OptimalControl.jl
 
-The `OptimalControl.jl` package is part of the [control-toolbox ecosystem](https://github.com/control-toolbox). It aims to provide tools to solve optimal control problems by direct and indirect methods. An optimal control problem can be described as minimising the cost functional
+```@meta
+CurrentModule =  OptimalControl
+```
+
+The `OptimalControl.jl` package is part of the [control-toolbox ecosystem](https://github.com/control-toolbox).
+
+!!! note "Install"
+
+    To install a package from the control-toolbox ecosystem, 
+    please visit the [installation page](https://github.com/control-toolbox#installation).
+
+This package aims to provide tools to solve optimal control problems by direct and indirect methods. An optimal control problem can be described as minimising the cost functional
 
 ```math
 g(t_0, x(t_0), t_f, x(t_f)) + \int_{t_0}^{t_f} f^{0}(t, x(t), u(t))~\mathrm{d}t
@@ -23,7 +34,3 @@ and other constraints such as
 \phi_l &\le& \phi(t_0, x(t_0), t_f, x(t_f)) &\le& \phi_u.
 \end{array}
 ```
-
-## Installation
-
-To install a package from the control-toolbox ecosystem, please visit the [installation page](https://github.com/control-toolbox#installation).