Merge pull request #145 from JuliaControl/new_ode_solver

added: new `ForwardEuler` solver with 0 allocation

Author: franckgaga

docs/src/public/sim_model.md

@@ -67,3 +67,9 @@ ModelPredictiveControl.DiffSolver
 ```@docs
 RungeKutta
 ```
+
+### ForwardEuler
+
+```@docs
+ForwardEuler
+```

src/ModelPredictiveControl.jl

@@ -23,7 +23,7 @@ import PreallocationTools: DiffCache, get_tmp
 import OSQP, Ipopt
 
 export SimModel, LinModel, NonLinModel
-export DiffSolver, RungeKutta
+export DiffSolver, RungeKutta, ForwardEuler
 export setop!, setname!
 export setstate!, setmodel!, preparestate!, updatestate!, evaloutput, linearize, linearize!
 export savetime!, periodsleep

src/controller/explicitmpc.jl

@@ -100,7 +100,7 @@ suitable for applications that require small sample times. The keyword arguments
 identical to [`LinMPC`](@ref), except for `Cwt` and `optim` which are not supported. 
 
 This method uses the default state estimator, a [`SteadyKalmanFilter`](@ref) with default
-arguments.
+arguments. This controller is allocation-free.
 
 # Examples
 ```jldoctest

src/controller/linmpc.jl

@@ -117,7 +117,7 @@ from ``j=0`` to ``H_p-1``. The slack variable ``ϵ`` relaxes the constraints, as
 in [`setconstraint!`](@ref) documentation. See Extended Help for a detailed nomenclature. 
 
 This method uses the default state estimator, a [`SteadyKalmanFilter`](@ref) with default
-arguments.
+arguments. This controller allocates memory at each time step for the optimization.
 
 # Arguments
 - `model::LinModel` : model used for controller predictions and state estimations.

src/controller/nonlinmpc.jl

@@ -144,6 +144,8 @@ This method uses the default state estimator:
 - if `model` is a [`LinModel`](@ref), a [`SteadyKalmanFilter`](@ref) with default arguments;
 - else, an [`UnscentedKalmanFilter`](@ref) with default arguments. 
 
+This controller allocates memory at each time step for the optimization.
+
 !!! warning
     See Extended Help if you get an error like:    
     `MethodError: no method matching Float64(::ForwardDiff.Dual)`.

src/estimator/internal_model.jl

@@ -71,7 +71,8 @@ Construct an internal model estimator based on `model` ([`LinModel`](@ref) or [`
 unmeasured ``\mathbf{y^u}``. `model` evaluates the deterministic predictions 
 ``\mathbf{ŷ_d}``, and `stoch_ym`, the stochastic predictions of the measured outputs 
 ``\mathbf{ŷ_s^m}`` (the unmeasured ones being ``\mathbf{ŷ_s^u=0}``). The predicted outputs
-sum both values : ``\mathbf{ŷ = ŷ_d + ŷ_s}``. See the Extended Help for more details.
+sum both values : ``\mathbf{ŷ = ŷ_d + ŷ_s}``. See the Extended Help for more details. This
+estimator is allocation-free is `model` simulations do not allocate.
 
 !!! warning
     `InternalModel` estimator does not work if `model` is integrating or unstable. The 

src/estimator/kalman.jl

@@ -101,7 +101,7 @@ on the covariance tuning. The matrices ``\mathbf{Ĉ^m, D̂_d^m}`` are the rows
 ``\mathbf{Ĉ, D̂_d}`` that correspond to measured outputs ``\mathbf{y^m}`` (and unmeasured
 ones, for ``\mathbf{Ĉ^u, D̂_d^u}``). The Kalman filter will estimate the current state with 
 the newest measurements ``\mathbf{x̂}_k(k)`` if `direct` is `true`, else it will predict the
-state of the next time step ``\mathbf{x̂}_k(k+1)``.
+state of the next time step ``\mathbf{x̂}_k(k+1)``. This estimator is allocation-free.
 
 # Arguments
 !!! info
@@ -352,6 +352,7 @@ the estimation error covariance of `model` states augmented with the stochastic
 ``\mathbf{P̂}_{-1}(0) = \mathrm{diag}\{ \mathbf{P}(0), \mathbf{P_{int_{u}}}(0), 
 \mathbf{P_{int_{ym}}}(0) \}``. The initial state estimate ``\mathbf{x̂}_{-1}(0)`` can be
 manually specified with [`setstate!`](@ref), or automatically with [`initstate!`](@ref).
+This estimator is allocation-free.
 
 # Arguments
 !!! info
@@ -596,6 +597,7 @@ matrix ``\mathbf{P̂}`` is the estimation error covariance of `model` state augm
 stochastic ones. Three keyword arguments specify its initial value with ``\mathbf{P̂}_{-1}(0) = 
 \mathrm{diag}\{ \mathbf{P}(0), \mathbf{P_{int_{u}}}(0), \mathbf{P_{int_{ym}}}(0) \}``. The 
 initial state estimate ``\mathbf{x̂}_{-1}(0)`` can be manually specified with [`setstate!`](@ref).
+This estimator is allocation-free if `model` simulations do not allocate.
 
 # Arguments
 !!! info
@@ -950,7 +952,7 @@ Both [`LinModel`](@ref) and [`NonLinModel`](@ref) are supported. The process mod
 keyword arguments are identical to [`UnscentedKalmanFilter`](@ref), except for `α`, `β` and 
 `κ` which do not apply to the extended Kalman Filter. The Jacobians of the augmented model 
 ``\mathbf{f̂, ĥ}`` are computed with [`ForwardDiff.jl`](https://github.com/JuliaDiff/ForwardDiff.jl)
-automatic differentiation.
+automatic differentiation. This estimator allocates memory for the Jacobians.
 
 !!! warning
     See the Extended Help of [`linearize`](@ref) function if you get an error like:    

src/estimator/luenberger.jl

@@ -78,6 +78,7 @@ elements specifying the observer poles/eigenvalues (near ``z=0.5`` by default).
 is constructed with a direct transmission from ``\mathbf{y^m}`` if `direct=true` (a.k.a. 
 current observers, in opposition to the delayed/prediction form). The method computes the
 observer gain `K̂` with [`place`](https://juliacontrol.github.io/ControlSystems.jl/stable/lib/synthesis/#ControlSystemsBase.place).
+This estimator is allocation-free.
 
 # Examples
 ```jldoctest

src/estimator/mhe/construct.jl

@@ -215,7 +215,8 @@ the keyword argument `direct=true` (default value), the constant ``p=0`` in the
 above, and the MHE is in the current form. Else ``p=1``, leading to the prediction form.
 
 See [`UnscentedKalmanFilter`](@ref) for details on the augmented process model and 
-``\mathbf{R̂}, \mathbf{Q̂}`` covariances.
+``\mathbf{R̂}, \mathbf{Q̂}`` covariances. This estimator allocates a fair amount of memory 
+at each time step.
 
 !!! warning
     See the Extended Help if you get an error like:    

src/model/linearization.jl

@@ -120,7 +120,8 @@ end
 
 Linearize `model` and store the result in `linmodel` (in-place).
 
-The keyword arguments are identical to [`linearize`](@ref).
+The keyword arguments are identical to [`linearize`](@ref). The code is allocation-free if
+`model` simulations does not allocate.
 
 # Examples
 ```jldoctest