small doc corrections

Author: franckgaga

.vscode/settings.json

@@ -50,6 +50,12 @@
         "OSQP",
         "Penrose",
         "Plamondon",
+        "plotry",
+        "plotu",
+        "plotx",
+        "plotx̂",
+        "plotŷ",
+        "plotŷmin",
         "predictstoch",
         "quadprog",
         "repeatdiag",

src/controller/linmpc.jl

@@ -120,14 +120,14 @@ arguments.
 - `model::LinModel` : model used for controller predictions and state estimations.
 - `Hp=10+nk`: prediction horizon ``H_p``, `nk` is the number of delays in `model`.
 - `Hc=2` : control horizon ``H_c``.
-- `Mwt=fill(1.0,model.ny)` : main diagonal of ``\mathbf{M}`` weight matrix (vector)
-- `Nwt=fill(0.1,model.nu)` : main diagonal of ``\mathbf{N}`` weight matrix (vector)
-- `Lwt=fill(0.0,model.nu)` : main diagonal of ``\mathbf{L}`` weight matrix (vector)
-- `Cwt=1e5` : slack variable weight ``C`` (scalar), use `Cwt=Inf` for hard constraints only
-- `ru=model.uop` : manipulated input setpoints ``\mathbf{r_u}`` (vector)
+- `Mwt=fill(1.0,model.ny)` : main diagonal of ``\mathbf{M}`` weight matrix (vector).
+- `Nwt=fill(0.1,model.nu)` : main diagonal of ``\mathbf{N}`` weight matrix (vector).
+- `Lwt=fill(0.0,model.nu)` : main diagonal of ``\mathbf{L}`` weight matrix (vector).
+- `Cwt=1e5` : slack variable weight ``C`` (scalar), use `Cwt=Inf` for hard constraints only.
+- `ru=model.uop` : manipulated input setpoints ``\mathbf{r_u}`` (vector).
 - `optim=JuMP.Model(OSQP.MathOptInterfaceOSQP.Optimizer)` : quadratic optimizer used in
   the predictive controller, provided as a [`JuMP.Model`](https://jump.dev/JuMP.jl/stable/reference/models/#JuMP.Model)
-  (default to [`OSQP.jl`](https://osqp.org/docs/parsers/jump.html) optimizer)
+  (default to [`OSQP.jl`](https://osqp.org/docs/parsers/jump.html) optimizer).
 
 # Examples
 ```jldoctest

src/controller/nonlinmpc.jl

@@ -118,16 +118,16 @@ This method uses the default state estimator :
 - `model::SimModel` : model used for controller predictions and state estimations.
 - `Hp=10`: prediction horizon ``H_p``.
 - `Hc=2` : control horizon ``H_c``.
-- `Mwt=fill(1.0,model.ny)` : main diagonal of ``\mathbf{M}`` weight matrix (vector)
-- `Nwt=fill(0.1,model.nu)` : main diagonal of ``\mathbf{N}`` weight matrix (vector)
-- `Lwt=fill(0.0,model.nu)` : main diagonal of ``\mathbf{L}`` weight matrix (vector)
-- `Cwt=1e5` : slack variable weight ``C`` (scalar), use `Cwt=Inf` for hard constraints only
+- `Mwt=fill(1.0,model.ny)` : main diagonal of ``\mathbf{M}`` weight matrix (vector).
+- `Nwt=fill(0.1,model.nu)` : main diagonal of ``\mathbf{N}`` weight matrix (vector).
+- `Lwt=fill(0.0,model.nu)` : main diagonal of ``\mathbf{L}`` weight matrix (vector).
+- `Cwt=1e5` : slack variable weight ``C`` (scalar), use `Cwt=Inf` for hard constraints only.
 - `Ewt=0.0` : economic costs weight ``E`` (scalar). 
 - `JE=(_,_,_)->0.0` : economic function ``J_E(\mathbf{U}_E, \mathbf{D̂}_E, \mathbf{Ŷ}_E)``.
-- `ru=model.uop` : manipulated input setpoints ``\mathbf{r_u}`` (vector)
-- `optim=JuMP.Model(Ipopt.Optimizer)` : nonlinear optimizer used in the predictive 
+- `ru=model.uop` : manipulated input setpoints ``\mathbf{r_u}`` (vector).
+- `optim=JuMP.Model(Ipopt.Optimizer)` : nonlinear optimizer used in the predictive
    controller, provided as a [`JuMP.Model`](https://jump.dev/JuMP.jl/stable/reference/models/#JuMP.Model)
-   (default to [`Ipopt.jl`](https://github.com/jump-dev/Ipopt.jl) optimizer)
+   (default to [`Ipopt.jl`](https://github.com/jump-dev/Ipopt.jl) optimizer).
 
 # Examples
 ```jldoctest

src/plot_sim.jl

@@ -13,15 +13,9 @@ struct SimResult{O<:Union{SimModel, StateEstimator, PredictiveController}}
 end
 
 @doc raw"""
-    sim!(
-        plant::SimModel, 
-        N::Int,
-        u::Vector{<:Real} = plant.uop .+ 1,
-        d::Vector{<:Real} = plant.dop;
-        <keyword arguments>
-    )
+    sim!(plant::SimModel, N::Int, u=plant.uop.+1, d=plant.dop; <keyword arguments>)
 
-Open-loop simulation of `plant` model for `N` time steps, default to input bumps.
+Open-loop simulation of `plant` for `N` time steps, default to input bumps.
 
 See Arguments for the available options. The noises are provided as standard deviations σ
 vectors. The simulated sensor and process noises of `plant` are specified by `y_noise` and
@@ -30,24 +24,24 @@ visualized by calling `plot` from [`Plots.jl`](https://github.com/JuliaPlots/Plo
 them (see Examples below).
 
 # Arguments
-- `plant::SimModel` : plant model to simulate
-- `N::Int` : simulation length in time steps
-- `u = estim.model.uop .+ 1` : manipulated input ``\mathbf{u}`` value
-- `d = estim.model.dop` : plant measured disturbance ``\mathbf{d}`` value
-- `u_step  = zeros(plant.nu)` : step disturbance on manipulated input ``\mathbf{u}``
-- `u_noise = zeros(plant.nu)` : additive gaussian noise on manipulated input ``\mathbf{u}``
-- `y_step  = zeros(plant.ny)` : step disturbance on plant outputs ``\mathbf{y}``
-- `y_noise = zeros(plant.ny)` : additive gaussian noise on plant outputs ``\mathbf{y}``
-- `d_step  = zeros(plant.nd)` : step on measured disturbances ``\mathbf{d}``
-- `d_noise = zeros(plant.nd)` : additive gaussian noise on measured dist. ``\mathbf{d}``
-- `x_noise = zeros(plant.nx)` : additive gaussian noise on plant states ``\mathbf{x}``
-- `x0 = zeros(plant.nx)` : plant initial state ``\mathbf{x}(0)``
+- `plant::SimModel` : plant model to simulate.
+- `N::Int` : simulation length in time steps.
+- `u = estim.model.uop .+ 1` : manipulated input ``\mathbf{u}`` value.
+- `d = estim.model.dop` : plant measured disturbance ``\mathbf{d}`` value.
+- `u_step  = zeros(plant.nu)` : step load disturbance on plant inputs ``\mathbf{u}``.
+- `u_noise = zeros(plant.nu)` : additive gaussian noise on plant inputs ``\mathbf{u}``.
+- `y_step  = zeros(plant.ny)` : step disturbance on plant outputs ``\mathbf{y}``.
+- `y_noise = zeros(plant.ny)` : additive gaussian noise on plant outputs ``\mathbf{y}``.
+- `d_step  = zeros(plant.nd)` : step on measured disturbances ``\mathbf{d}``.
+- `d_noise = zeros(plant.nd)` : additive gaussian noise on measured dist. ``\mathbf{d}``.
+- `x_noise = zeros(plant.nx)` : additive gaussian noise on plant states ``\mathbf{x}``.
+- `x0 = zeros(plant.nx)` : plant initial state ``\mathbf{x}(0)``.
 
 # Examples
 ```julia-repl
-julia> plant = NonLinModel((x,u,d)->0.1x+u+d, (x,_)->2x, 10, 1, 1, 1);
+julia> plant = NonLinModel((x,u,d)->0.1x+u+d, (x,_)->2x, 10, 1, 1, 1, 1);
 
-julia> res = sim!(plant, 5, [0], [0], x0=[1]);
+julia> res = sim!(plant, 15, [0], [0], x0=[1]);
 
 julia> using Plots; plot(res, plotu=false, plotd=false, plotx=true)
 ```
@@ -93,10 +87,10 @@ end
 
 @doc raw"""
     sim!(
-        estim::StateEstimator, 
-        N::Int, 
-        u = estim.model.uop .+ 1, 
-        d = estim.model.dop; 
+        estim::StateEstimator,
+        N::Int,
+        u = estim.model.uop .+ 1,
+        d = estim.model.dop;
         <keyword arguments>
     )
 
@@ -105,15 +99,15 @@ Closed-loop simulation of `estim` estimator for `N` time steps, default to input
 See Arguments for the available options. 
 
 # Arguments
-- `estim::StateEstimator` : state estimator to simulate
-- `N::Int` : simulation length in time steps
-- `u = estim.model.uop .+ 1` : manipulated input ``\mathbf{u}`` value
-- `d = estim.model.dop` : plant measured disturbance ``\mathbf{d}`` value
-- `plant::SimModel = estim.model` : simulated plant model
+- `estim::StateEstimator` : state estimator to simulate.
+- `N::Int` : simulation length in time steps.
+- `u = estim.model.uop .+ 1` : manipulated input ``\mathbf{u}`` value.
+- `d = estim.model.dop` : plant measured disturbance ``\mathbf{d}`` value.
+- `plant::SimModel = estim.model` : simulated plant model.
 - `x̂0 = nothing` : `mpc.estim` state estimator initial state ``\mathbf{x̂}(0)``, if `nothing`
-   then ``\mathbf{x̂}`` is initialized with [`initstate!`](@ref)
-- `lastu = plant.uop` : last plant input ``\mathbf{u}`` for ``\mathbf{x̂}`` initialization
-- `<keyword arguments>` of [`sim!(::SimModel)`](@ref)
+   then ``\mathbf{x̂}`` is initialized with [`initstate!`](@ref).
+- `lastu = plant.uop` : last plant input ``\mathbf{u}`` for ``\mathbf{x̂}`` initialization.
+- `<keyword arguments>` of [`sim!(::SimModel, ::Int)`](@ref).
 
 # Examples
 ```julia-repl
@@ -140,26 +134,26 @@ end
 @doc raw"""
     sim!(
         mpc::PredictiveController, 
-        N::Int, 
+        N::Int,
         ry = mpc.estim.model.yop .+ 1, 
         d  = mpc.estim.model.dop; 
         <keyword arguments>
     )
 
 Closed-loop simulation of `mpc` controller for `N` time steps, default to setpoint bumps.
 
-`ry` is the output setpoint value applied at ``t = 0`` second. The keyword arguments are
-identical to [`sim!(::StateEstimator)`](@ref).
+The argument `ry` is output setpoint ``\mathbf{r_y}`` value applied at ``t = 0``. The 
+keyword arguments are identical to [`sim!(::StateEstimator, ::Int)`](@ref).
 
 # Examples
 ```julia-repl
 julia> model = LinModel([tf(3, [30, 1]); tf(2, [5, 1])], 4);
 
 julia> mpc = setconstraint!(LinMPC(model, Mwt=[0, 1], Nwt=[0.01], Hp=30), ŷmin=[0, -Inf]);
 
-julia> res = sim!(mpc, 25, [0; 0], y_noise=[0.1], y_step=[-10,0]);
+julia> res = sim!(mpc, 25, [0, 0], y_noise=[0.1], y_step=[-10, 0]);
 
-julia> using Plots; plot(res, plotRy=true, plotŷ=true, plotŷmin=true, plotu=true)
+julia> using Plots; plot(res, plotry=true, plotŷ=true, plotŷmin=true, plotu=true)
 ```
 """
 function sim!(