replace d=Float64[] with empty calls

Author: franckgaga

src/controller/explicitmpc.jl

@@ -42,7 +42,7 @@ struct ExplicitMPC{S<:StateEstimator} <: PredictiveController
         L_Hp = Diagonal{Float64}(repeat(Lwt, Hp))
         C = Cwt
         # manipulated input setpoint predictions are constant over Hp :
-        R̂u = ~iszero(Lwt) ? repeat(ru, Hp) : R̂u = Float64[]
+        R̂u = ~iszero(Lwt) ? repeat(ru, Hp) : R̂u = empty(estim.x̂)
         R̂y = zeros(ny* Hp) # dummy R̂y (updated just before optimization)
         S_Hp, T_Hp, S_Hc, T_Hc = init_ΔUtoU(nu, Hp, Hc)
         E, F, G, J, K, Q = init_predmat(estim, model, Hp, Hc)

src/controller/linmpc.jl

@@ -42,7 +42,7 @@ struct LinMPC{S<:StateEstimator} <: PredictiveController
         L_Hp = Diagonal{Float64}(repeat(Lwt, Hp))
         C = Cwt
         # manipulated input setpoint predictions are constant over Hp :
-        R̂u = ~iszero(Lwt) ? repeat(ru, Hp) : R̂u = Float64[]
+        R̂u = ~iszero(Lwt) ? repeat(ru, Hp) : R̂u = empty(estim.x̂)
         R̂y = zeros(ny* Hp) # dummy R̂y (updated just before optimization)
         S_Hp, T_Hp, S_Hc, T_Hc = init_ΔUtoU(nu, Hp, Hc)
         E, F, G, J, K, Q = init_predmat(estim, model, Hp, Hc)

src/controller/nonlinmpc.jl

@@ -46,7 +46,7 @@ struct NonLinMPC{S<:StateEstimator, JEfunc<:Function} <: PredictiveController
         L_Hp = Diagonal(convert(Vector{Float64}, repeat(Lwt, Hp)))
         C = Cwt
         # manipulated input setpoint predictions are constant over Hp :
-        R̂u = ~iszero(Lwt) ? repeat(ru, Hp) : R̂u = Float64[] 
+        R̂u = ~iszero(Lwt) ? repeat(ru, Hp) : R̂u = empty(estim.x̂) 
         R̂y = zeros(ny* Hp) # dummy R̂y (updated just before optimization)
         S_Hp, T_Hp, S_Hc, T_Hc = init_ΔUtoU(nu, Hp, Hc)
         E, F, G, J, K, Q = init_predmat(estim, model, Hp, Hc)

src/estimator/internal_model.jl

@@ -187,7 +187,7 @@ function init_internalmodel(As, Bs, Cs, Ds)
 end
 
 @doc raw"""
-    update_estimate!(estim::InternalModel, u, ym, d=Float64[]) -> x̂d
+    update_estimate!(estim::InternalModel, u, ym, d=empty(estim.x̂)) -> x̂d
 
 Update `estim.x̂` \ `x̂d` \ `x̂s` with current inputs `u`, measured outputs `ym` and dist. `d`.
 
@@ -201,7 +201,7 @@ The [`InternalModel`](@ref) updates the deterministic `x̂d` and stochastic `x̂
 This estimator does not augment the state vector, thus ``\mathbf{x̂ = x̂_d}``. See 
 [`init_internalmodel`](@ref) for details. 
 """
-function update_estimate!(estim::InternalModel, u, ym, d=Float64[])
+function update_estimate!(estim::InternalModel, u, ym, d=empty(estim.x̂))
     model = estim.model
     x̂d, x̂s = estim.x̂d, estim.x̂s
     # -------------- deterministic model ---------------------
@@ -232,5 +232,5 @@ function print_estim_dim(io::IO, estim::InternalModel, n)
     print(io,   "$(lpad(nd, n)) measured disturbances d")
 end
 
-(estim::InternalModel)(ym, d=Float64[]) = evaloutput(estim::InternalModel, ym, d)
+(estim::InternalModel)(ym, d=empty(estim.x̂)) = evaloutput(estim::InternalModel, ym, d)
 

src/estimator/kalman.jl

@@ -172,7 +172,7 @@ The [`SteadyKalmanFilter`](@ref) updates it with the precomputed Kalman gain ``\
                + \mathbf{K̂}[\mathbf{y^m}(k) - \mathbf{Ĉ^m x̂}_{k-1}(k) - \mathbf{D̂_d^m d}(k)]
 ```
 """
-function update_estimate!(estim::SteadyKalmanFilter, u, ym, d=Float64[])
+function update_estimate!(estim::SteadyKalmanFilter, u, ym, d=empty(estim.x̂))
     Â, B̂u, B̂d, Ĉm, D̂dm = estim.Â, estim.B̂u, estim.B̂d, estim.Ĉm, estim.D̂dm
     x̂, K̂ = estim.x̂, estim.K̂
     x̂[:] = Â*x̂ + B̂u*u + B̂d*d + K̂*(ym - Ĉm*x̂ - D̂dm*d)
@@ -688,7 +688,7 @@ This syntax allows nonzero off-diagonal elements in ``\mathbf{P̂}_{-1}(0), \mat
 ExtendedKalmanFilter{M}(model::M, i_ym, nint_u, nint_ym, P̂0, Q̂, R̂) where {M<:SimModel}
 
 @doc raw"""
-    update_estimate!(estim::ExtendedKalmanFilter, u, ym, d=Float64[])
+    update_estimate!(estim::ExtendedKalmanFilter, u, ym, d=empty(estim.x̂))
 
 Update [`ExtendedKalmanFilter`](@ref) state `estim.x̂` and covariance `estim.P̂`.
 
@@ -717,7 +717,7 @@ automatically computes the Jacobians:
 ```
 The matrix ``\mathbf{Ĥ^m}`` is the rows of ``\mathbf{Ĥ}`` that are measured outputs.
 """
-function update_estimate!(estim::ExtendedKalmanFilter, u, ym, d=Float64[])
+function update_estimate!(estim::ExtendedKalmanFilter, u, ym, d=empty(estim.x̂))
     F̂  = ForwardDiff.jacobian(x̂ -> f̂(estim, x̂, u, d), estim.x̂)
     Ĥ  = ForwardDiff.jacobian(x̂ -> ĥ(estim, x̂, d), estim.x̂)
     Ĥm = Ĥ[estim.i_ym, :] 

src/estimator/luenberger.jl

@@ -94,11 +94,11 @@ end
 
 
 """
-    update_estimate!(estim::Luenberger, u, ym, d=Float64[])
+    update_estimate!(estim::Luenberger, u, ym, d=empty(estim.x̂))
 
 Same than [`update_estimate!(::SteadyKalmanFilter)`](@ref) but using [`Luenberger`](@ref).
 """
-function update_estimate!(estim::Luenberger, u, ym, d=Float64[])
+function update_estimate!(estim::Luenberger, u, ym, d=empty(estim.x̂))
     Â, B̂u, B̂d, Ĉm, D̂dm = estim.Â, estim.B̂u, estim.B̂d, estim.Ĉm, estim.D̂dm
     x̂, K̂ = estim.x̂, estim.K̂
     x̂[:] = Â*x̂ + B̂u*u + B̂d*d + K̂*(ym - Ĉm*x̂ - D̂dm*d)

src/predictive_control.jl

@@ -3,7 +3,7 @@ Abstract supertype of all predictive controllers.
 
 ---
 
-    (mpc::PredictiveController)(ry, d=Float64[]; kwargs...)
+    (mpc::PredictiveController)(ry, d=[]; kwargs...)
 
 Functor allowing callable `PredictiveController` object as an alias for [`moveinput!`](@ref).
 
@@ -50,7 +50,7 @@ struct ControllerConstraint
 end
 
 @doc raw"""
-    setconstraint!(mpc::PredictiveController; <keyword arguments>)
+    setconstraint!(mpc::PredictiveController; <keyword arguments>) -> mpc
 
 Set the constraint parameters of `mpc` predictive controller.
 
@@ -241,7 +241,7 @@ setnonlincon!(::PredictiveController, ::SimModel) = nothing
     moveinput!(
         mpc::PredictiveController, 
         ry = mpc.estim.model.yop, 
-        d  = Float64[];
+        d  = [];
         R̂y = repeat(ry, mpc.Hp), 
         D̂  = repeat(d,  mpc.Hp), 
         ym = nothing
@@ -277,7 +277,7 @@ julia> ry = [5]; u = moveinput!(mpc, ry); round.(u, digits=3)
 function moveinput!(
     mpc::PredictiveController, 
     ry::Vector = mpc.estim.model.yop, 
-    d ::Vector = Float64[];
+    d ::Vector = empty(mpc.estim.x̂);
     R̂y::Vector = repeat(ry, mpc.Hp),
     D̂ ::Vector = repeat(d,  mpc.Hp),
     ym::Union{Vector, Nothing} = nothing
@@ -357,22 +357,22 @@ Set the estimate at `mpc.estim.x̂`.
 setstate!(mpc::PredictiveController, x̂) = (setstate!(mpc.estim, x̂); return mpc)
 
 @doc raw"""
-    initstate!(mpc::PredictiveController, u, ym, d=Float64[])
+    initstate!(mpc::PredictiveController, u, ym, d=[]) -> x̂
 
 Init the states of `mpc.estim` [`StateEstimator`](@ref) and warm start `mpc.ΔŨ` at zero.
 """
-function initstate!(mpc::PredictiveController, u, ym, d=Float64[])
+function initstate!(mpc::PredictiveController, u, ym, d=empty(mpc.estim.x̂))
     mpc.ΔŨ .= 0
     return initstate!(mpc.estim, u, ym, d)
 end
 
 
 """
-    updatestate!(mpc::PredictiveController, u, ym, d=Float64[]) -> x̂
+    updatestate!(mpc::PredictiveController, u, ym, d=[]) -> x̂
 
 Call [`updatestate!`](@ref) on `mpc.estim` [`StateEstimator`](@ref).
 """
-updatestate!(mpc::PredictiveController, u, ym, d=Float64[]) = updatestate!(mpc.estim,u,ym,d)
+updatestate!(mpc::PredictiveController, u, ym, d=empty(mpc.estim.x̂)) = updatestate!(mpc.estim,u,ym,d)
 updatestate!(::PredictiveController, _ ) = throw(ArgumentError("missing measured outputs ym"))
 
 function validate_setpointdist(mpc::PredictiveController, ry, d, R̂y, D̂)
@@ -1051,7 +1051,7 @@ end
 "Functor allowing callable `PredictiveController` object as an alias for `moveinput!`."
 function (mpc::PredictiveController)(
     ry::Vector = mpc.estim.model.yop, 
-    d ::Vector = Float64[];
+    d ::Vector = empty(mpc.estim.x̂);
     kwargs...
 )
     return moveinput!(mpc, ry, d; kwargs...)

src/sim_model.jl

@@ -5,7 +5,7 @@ Abstract supertype of [`LinModel`](@ref) and [`NonLinModel`](@ref) types.
 
 ---
 
-    (model::SimModel)(d=Float64[])
+    (model::SimModel)(d=[]) -> y
 
 Functor allowing callable `SimModel` object as an alias for [`evaloutput`](@ref).
 
@@ -21,7 +21,7 @@ julia> y = model()
 abstract type SimModel end
 
 @doc raw"""
-    setop!(model::SimModel; uop=nothing, yop=nothing, dop=nothing)
+    setop!(model::SimModel; uop=nothing, yop=nothing, dop=nothing) -> model
 
 Set `model` inputs `uop`, outputs `yop` and measured disturbances `dop` operating points.
 
@@ -99,7 +99,7 @@ function Base.show(io::IO, model::SimModel)
 end
 
 @doc raw"""
-    initstate!(model::SimModel, u, d=Float64[]) -> x
+    initstate!(model::SimModel, u, d=[]) -> x
 
 Init `model.x` with manipulated inputs `u` and measured disturbances `d` steady-state.
 
@@ -121,13 +121,13 @@ true
 ```
 
 """
-function initstate!(model::SimModel, u, d=Float64[])
+function initstate!(model::SimModel, u, d=empty(model.x))
     steadystate!(model, u, d)
     return model.x
 end
 
 """
-    updatestate!(model::SimModel, u, d=Float64[]) -> x
+    updatestate!(model::SimModel, u, d=[]) -> x
 
 Update `model.x` states with current inputs `u` and measured disturbances `d`.
 
@@ -140,13 +140,13 @@ julia> x = updatestate!(model, [1])
  1.0
 ```
 """
-function updatestate!(model::SimModel, u, d=Float64[])
+function updatestate!(model::SimModel, u, d=empty(model.x))
     model.x[:] = f(model, model.x, u - model.uop, d - model.dop)
     return model.x
 end
 
 """
-    evaloutput(model::SimModel, d=Float64[]) -> y
+    evaloutput(model::SimModel, d=[]) -> y
 
 Evaluate `SimModel` outputs `y` from `model.x` states and measured disturbances `d`.
 
@@ -161,10 +161,10 @@ julia> y = evaloutput(model)
  20.0
 ```
 """
-evaloutput(model::SimModel, d=Float64[]) = h(model, model.x, d - model.dop) + model.yop
+evaloutput(model::SimModel, d=empty(model.x)) = h(model, model.x, d - model.dop) + model.yop
 
 "Functor allowing callable `SimModel` object as an alias for `evaloutput`."
-(model::SimModel)(d=Float64[]) = evaloutput(model::SimModel, d)
+(model::SimModel)(d=empty(model.x)) = evaloutput(model::SimModel, d)
 
 include("model/linmodel.jl")
 include("model/nonlinmodel.jl")

src/state_estim.jl

@@ -3,7 +3,7 @@ Abstract supertype of all state estimators.
 
 ---
 
-    (estim::StateEstimator)(d=Float64[])
+    (estim::StateEstimator)(d=[]) -> ŷ
 
 Functor allowing callable `StateEstimator` object as an alias for [`evaloutput`](@ref).
 
@@ -213,7 +213,7 @@ end
 
 
 @doc raw"""
-    default_nint(model::LinModel, i_ym=1:model.ny, nint_u=0)
+    default_nint(model::LinModel, i_ym=1:model.ny, nint_u=0) -> nint_ym
 
 Get default integrator quantity per measured outputs `nint_ym` for [`LinModel`](@ref).
 
@@ -288,7 +288,7 @@ end
 
 
 @doc raw"""
-    initstate!(estim::StateEstimator, u, ym, d=Float64[]) -> x̂
+    initstate!(estim::StateEstimator, u, ym, d=[]) -> x̂
 
 Init `estim.x̂` states from current inputs `u`, measured outputs `ym` and disturbances `d`.
 
@@ -321,7 +321,7 @@ true
 ```
 
 """
-function initstate!(estim::StateEstimator, u, ym, d=Float64[])
+function initstate!(estim::StateEstimator, u, ym, d=empty(estim.x̂))
     # --- init state estimate ----
     u0, d0, ym0 = remove_op!(estim, u, d, ym)
     init_estimate!(estim, estim.model, u0, ym0, d0)
@@ -362,7 +362,7 @@ end
 init_estimate!(::StateEstimator, ::SimModel, _ , _ , _ ) = nothing
 
 @doc raw"""
-    evaloutput(estim::StateEstimator, d=Float64[]) -> ŷ
+    evaloutput(estim::StateEstimator, d=[]) -> ŷ
 
 Evaluate `StateEstimator` outputs `ŷ` from `estim.x̂` states and disturbances `d`.
 
@@ -377,16 +377,16 @@ julia> ŷ = evaloutput(kf)
  20.0
 ```
 """
-function evaloutput(estim::StateEstimator, d=Float64[]) 
+function evaloutput(estim::StateEstimator, d=empty(estim.x̂)) 
     return ĥ(estim, estim.x̂, d - estim.model.dop) + estim.model.yop
 end
 
 "Functor allowing callable `StateEstimator` object as an alias for `evaloutput`."
-(estim::StateEstimator)(d=Float64[]) = evaloutput(estim, d)
+(estim::StateEstimator)(d=empty(estim.x̂)) = evaloutput(estim, d)
 
 
 @doc raw"""
-    updatestate!(estim::StateEstimator, u, ym, d=Float64[]) -> x̂
+    updatestate!(estim::StateEstimator, u, ym, d=[]) -> x̂
 
 Update `estim.x̂` estimate with current inputs `u`, measured outputs `ym` and dist. `d`. 
 
@@ -403,7 +403,7 @@ julia> x̂ = updatestate!(kf, [1], [0]) # x̂[2] is the integrator state (nint_y
  0.0
 ```
 """
-function updatestate!(estim::StateEstimator, u, ym, d=Float64[])
+function updatestate!(estim::StateEstimator, u, ym, d=empty(estim.x̂))
     u0, d0, ym0 = remove_op!(estim, u, d, ym) 
     update_estimate!(estim, u0, ym0, d0)
     return estim.x̂