doc: clean up in the inter-links

Author: franckgaga

docs/make.jl

@@ -11,6 +11,7 @@ links = InterLinks(
     "ControlSystemsBase" => "https://juliacontrol.github.io/ControlSystems.jl/stable/objects.inv",
     "JuMP" => "https://jump.dev/JuMP.jl/stable/objects.inv",
     "DifferentiationInterface" => "https://juliadiff.org/DifferentiationInterface.jl/DifferentiationInterface/stable/objects.inv",
+    "ForwardDiff" => "https://juliadiff.org/ForwardDiff.jl/stable/objects.inv",
 )
 
 DocMeta.setdocmeta!(

docs/src/manual/nonlinmpc.md

@@ -329,7 +329,7 @@ Nonlinear MPC is more computationally expensive than [`LinMPC`](@ref). Solving t
 should always be faster than the sampling time ``T_s = 0.1`` s for real-time operation. This
 requirement is sometimes hard to meet on electronics or mechanical systems because of the
 fast dynamics. To ease the design and comparison with [`LinMPC`](@ref), the [`linearize`](@ref)
-function allows automatic linearization of [`NonLinModel`](@ref) based on [`ForwardDiff.jl`](https://juliadiff.org/ForwardDiff.jl/stable/).
+function allows automatic linearization of [`NonLinModel`](@ref) based on [`ForwardDiff`](@extref ForwardDiff).
 We first linearize `model` at the point ``θ = π`` rad and ``ω = τ = 0`` (inverted position):
 
 ```@example man_nonlin

src/controller/nonlinmpc.jl

@@ -196,7 +196,7 @@ This controller allocates memory at each time step for the optimization.
 - `optim=JuMP.Model(Ipopt.Optimizer)` : nonlinear optimizer used in the predictive
    controller, provided as a [`JuMP.Model`](@extref) object (default to [`Ipopt`](https://github.com/jump-dev/Ipopt.jl) optimizer).
 - `gradient=AutoForwardDiff()` : an `AbstractADType` backend for the gradient of the objective
-   function, see [`DifferentiationInterface`](@extref DifferentiationInterface List).
+   function, see [`DifferentiationInterface` doc](@extref DifferentiationInterface List).
 - `jacobian=default_jacobian(transcription)` : an `AbstractADType` backend for the Jacobian
    of the nonlinear constraints, see `gradient` above for the options (default in Extended Help).
 - additional keyword arguments are passed to [`UnscentedKalmanFilter`](@ref) constructor 
@@ -247,16 +247,16 @@ NonLinMPC controller with a sample time Ts = 10.0 s, Ipopt optimizer, UnscentedK
     The keyword argument `nc` is the number of elements in `LHS`, and `gc!`, an alias for
     the `gc` argument (both `gc` and `gc!` accepts non-mutating and mutating functions). 
     
-    By default, the optimization relies on dense [`ForwardDiff`](https://github.com/JuliaDiff/ForwardDiff.jl)
+    By default, the optimization relies on dense [`ForwardDiff`](@extref ForwardDiff)
     automatic differentiation (AD) to compute the objective and constraint derivatives. One
     exception: if `transcription` is not a [`SingleShooting`](@ref), the `jacobian` argument
-    defaults to this [sparse backend](@extref DifferentiationInterface Sparsity):
+    defaults to this [sparse backend](@extref DifferentiationInterface AutoSparse-object):
     ```julia
-        AutoSparse(
-            AutoForwardDiff(); 
-            sparsity_detector  = TracerSparsityDetector(), 
-            coloring_algorithm = GreedyColoringAlgorithm()
-        )
+    AutoSparse(
+        AutoForwardDiff(); 
+        sparsity_detector  = TracerSparsityDetector(), 
+        coloring_algorithm = GreedyColoringAlgorithm()
+    )
     ```
     Optimizers generally benefit from exact derivatives like AD. However, the [`NonLinModel`](@ref) 
     state-space functions must be compatible with this feature. See [`JuMP` documentation](@extref JuMP Common-mistakes-when-writing-a-user-defined-operator)

src/estimator/kalman.jl

@@ -951,8 +951,8 @@ Construct an extended Kalman Filter with the [`SimModel`](@ref) `model`.
 Both [`LinModel`](@ref) and [`NonLinModel`](@ref) are supported. The process model and the
 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. This estimator allocates memory for the Jacobians.
+``\mathbf{f̂, ĥ}`` are computed with [`ForwardDiff`](@extref ForwardDiff) automatic
+differentiation. This estimator allocates memory for the Jacobians.
 
 !!! warning
     See the Extended Help of [`linearize`](@ref) function if you get an error like:    
@@ -1043,9 +1043,9 @@ augmented process model:
 \end{aligned}
 ```
 The matrix ``\mathbf{Ĥ^m}`` is the rows of ``\mathbf{Ĥ}`` that are measured outputs. The
-function [`ForwardDiff.jacobian`](https://juliadiff.org/ForwardDiff.jl/stable/user/api/#ForwardDiff.jacobian)
-automatically computes them. The correction and prediction step equations are provided below.
-The correction step is skipped if `estim.direct == true` since it's already done by the user.
+Jacobians are computed with [`ForwardDiff`](@extref ForwardDiff). The correction and 
+prediction step equations are provided below. The correction step is skipped if 
+`estim.direct == true` since it's already done by the user.
 
 # Correction Step
 ```math

src/estimator/mhe/construct.jl

@@ -261,7 +261,7 @@ transcription for now.
    nonlinear optimizer for solving (default to [`Ipopt`](https://github.com/jump-dev/Ipopt.jl),
    or [`OSQP`](https://osqp.org/docs/parsers/jump.html) if `model` is a [`LinModel`](@ref)).
 - `gradient=AutoForwardDiff()` : an `AbstractADType` backend for the gradient of the objective
-   function if `model` is not a [`LinModel`](@ref), see [`DifferentiationInterface`][@extref DifferentiationInterface List].
+   function if `model` is not a [`LinModel`](@ref), see [`DifferentiationInterface` doc](@extref DifferentiationInterface List).
 - `jacobian=AutoForwardDiff()` : an `AbstractADType` backend for the Jacobian of the
    constraints if `model` is not a [`LinModel`](@ref), see `gradient` above for the options.
 - `direct=true`: construct with a direct transmission from ``\mathbf{y^m}`` (a.k.a. current

src/model/linearization.jl

@@ -75,7 +75,7 @@ Linearize `model` at the operating points `x`, `u`, `d` and return the [`LinMode
 The arguments `x`, `u` and `d` are the linearization points for the state ``\mathbf{x}``,
 manipulated input ``\mathbf{u}`` and measured disturbance ``\mathbf{d}``, respectively (not
 necessarily an equilibrium, details in Extended Help). The Jacobians of ``\mathbf{f}`` and 
-``\mathbf{h}`` functions are automatically computed with [`ForwardDiff.jl`](https://github.com/JuliaDiff/ForwardDiff.jl).
+``\mathbf{h}`` functions are automatically computed with [`ForwardDiff`](@extref ForwardDiff).
 
 !!! warning
     See Extended Help if you get an error like:    
@@ -131,7 +131,7 @@ julia> linmodel.A
     equations are similar if the nonlinear model has nonzero operating points.
 
     Automatic differentiation (AD) allows exact Jacobians. The [`NonLinModel`](@ref) `f` and
-    `h` functions must be compatible with this feature though. See [`JuMP` documentation][@extref JuMP Common-mistakes-when-writing-a-user-defined-operator]
+    `h` functions must be compatible with this feature though. See [`JuMP` documentation](@extref JuMP Common-mistakes-when-writing-a-user-defined-operator)
     for common mistakes when writing these functions.
 """
 function linearize(model::SimModel{NT}; kwargs...) where NT<:Real

src/model/nonlinmodel.jl

@@ -96,12 +96,10 @@ form. The optional parameter `NT` explicitly set the number type of vectors (def
 !!! warning
     The two functions must be in pure Julia to use the model in [`NonLinMPC`](@ref),
     [`ExtendedKalmanFilter`](@ref), [`MovingHorizonEstimator`](@ref) and [`linearize`](@ref),
-    except if a finite difference backend is used (e.g. [`AutoFiniteDiff`][1]).
+    except if a finite difference backend is used (e.g. [`AutoFiniteDiff`](@extref DifferentiationInterface List).
 
 See also [`LinModel`](@ref).
 
-[1]: https://juliadiff.org/DifferentiationInterface.jl/DifferentiationInterface/stable/explanation/backends/#List
-
 # Examples
 ```jldoctest
 julia> f!(ẋ, x, u, _ , p) = (ẋ .= p*x .+ u; nothing);