added: jacobian argument to NonLinModel constructor

Author: franckgaga

src/controller/linmpc.jl

@@ -135,7 +135,7 @@ arguments. This controller allocates memory at each time step for the optimizati
 
 # 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`.
+- `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).

src/model/nonlinmodel.jl

@@ -70,8 +70,8 @@ struct NonLinModel{
 end
 
 @doc raw"""
-    NonLinModel{NT}(f::Function,  h::Function,  Ts, nu, nx, ny, nd=0; p=[], solver=RungeKutta(4))
-    NonLinModel{NT}(f!::Function, h!::Function, Ts, nu, nx, ny, nd=0; p=[], solver=RungeKutta(4))
+    NonLinModel{NT}(f::Function,  h::Function,  Ts, nu, nx, ny, nd=0; <keyword arguments>)
+    NonLinModel{NT}(f!::Function, h!::Function, Ts, nu, nx, ny, nd=0; <keyword arguments>)
 
 Construct a nonlinear model from state-space functions `f`/`f!` and `h`/`h!`.
 
@@ -86,24 +86,20 @@ functions are defined as:
 ```
 where ``\mathbf{x}``, ``\mathbf{y}``, ``\mathbf{u}``, ``\mathbf{d}`` and ``\mathbf{p}`` are
 respectively the state, output, manipulated input, measured disturbance and parameter
-vectors. If the dynamics is a function of the time, simply add a measured disturbance
-defined as ``d(t) = t``. The functions can be implemented in two possible ways:
+vectors. As a mather of fact, the parameter argument `p` can be any Julia objects but use a
+mutable type if you want to change them later e.g.: a vector. If the dynamics is a function
+of the time, simply add a measured disturbance defined as ``d(t) = t``. The functions can be
+implemented in two possible ways:
 
 1. **Non-mutating functions** (out-of-place): define them as `f(x, u, d, p) -> ẋ` and
    `h(x, d, p) -> y`. This syntax is simple and intuitive but it allocates more memory.
 2. **Mutating functions** (in-place): define them as `f!(ẋ, x, u, d, p) -> nothing` and
    `h!(y, x, d, p) -> nothing`. This syntax reduces the allocations and potentially the 
    computational burden as well.
 
-`Ts` is the sampling time in second. `nu`, `nx`, `ny` and `nd` are the respective number of 
-manipulated inputs, states, outputs and measured disturbances. The keyword argument `p`
-is the parameters of the model passed to the two functions. It can be any Julia objects but
-use a mutable type if you want to change them later e.g.: a vector.
-
 !!! tip
     Replace the `d` or `p` argument with `_` in your functions if not needed (see Examples below).
     
-A 4th order [`RungeKutta`](@ref) solver discretizes the differential equations by default. 
 The rest of the documentation assumes discrete dynamics since all models end up in this 
 form. The optional parameter `NT` explicitly set the number type of vectors (default to 
 `Float64`).
@@ -115,6 +111,20 @@ form. The optional parameter `NT` explicitly set the number type of vectors (def
 
 See also [`LinModel`](@ref).
 
+# Arguments
+- `f::Function` or `f!`: state function.
+- `h::Function` or `h!`: output function.
+- `Ts`: sampling time of in second.
+- `nu`: number of manipulated inputs.
+- `nx`: number of states.
+- `ny`: number of outputs.
+- `nd=0`: number of measured disturbances.
+- `p=[]`: parameters of the model (any type).
+- `solver=RungeKutta(4)`: a [`DiffSolver`](@ref) object for the discretization of continuous
+  dynamics, use `nothing` for discrete-time models (default to 4th order [`RungeKutta`](@ref)).
+- `jacobian=AutoForwardDiff()`: an `AbstractADType` backend when [`linearize`](@ref) is
+   called, see [`DifferentiationInterface` doc](@extref DifferentiationInterface List).
+
 # Examples
 ```jldoctest
 julia> f!(ẋ, x, u, _ , p) = (ẋ .= p*x .+ u; nothing);