debug julia 1.6

debug: re-insert precompile calls

Author: franckgaga

src/controller/explicitmpc.jl

@@ -12,8 +12,8 @@ struct ExplicitMPC{NT<:Real, SE<:StateEstimator} <: PredictiveController{NT}
     R̂u::Vector{NT}
     R̂y::Vector{NT}
     noR̂u::Bool
-    S̃::Matrix{Bool}
-    T::Matrix{Bool}
+    S̃::BitMatrix
+    T::BitMatrix
     Ẽ::Matrix{NT}
     F::Vector{NT}
     G::Matrix{NT}

src/controller/linmpc.jl

@@ -22,8 +22,8 @@ struct LinMPC{
     R̂u::Vector{NT}
     R̂y::Vector{NT}
     noR̂u::Bool
-    S̃::Matrix{Bool}
-    T::Matrix{Bool}
+    S̃::BitMatrix
+    T::BitMatrix
     Ẽ::Matrix{NT}
     F::Vector{NT}
     G::Matrix{NT}

src/controller/nonlinmpc.jl

@@ -24,8 +24,8 @@ struct NonLinMPC{
     R̂u::Vector{NT}
     R̂y::Vector{NT}
     noR̂u::Bool
-    S̃::Matrix{Bool}
-    T::Matrix{Bool}
+    S̃::BitMatrix
+    T::BitMatrix
     Ẽ::Matrix{NT}
     F::Vector{NT}
     G::Matrix{NT}

src/estimator/kalman.jl

@@ -160,7 +160,10 @@ Construct the estimator from the augmented covariance matrices `Q̂` and `R̂`.
 
 This syntax allows nonzero off-diagonal elements in ``\mathbf{Q̂, R̂}``.
 """
-SteadyKalmanFilter(model::LinModel, i_ym, nint_u, nint_ym, Q̂, R̂)
+function SteadyKalmanFilter(model::SM, i_ym, nint_u, nint_ym, Q̂, R̂) where {NT<:Real, SM<:LinModel{NT}}
+    return SteadyKalmanFilter{NT, SM}(model, i_ym, nint_u, nint_ym, Q̂ , R̂)
+end
+
 
 
 @doc raw"""
@@ -298,7 +301,9 @@ Construct the estimator from the augmented covariance matrices `P̂0`, `Q̂` and
 
 This syntax allows nonzero off-diagonal elements in ``\mathbf{P̂}_{-1}(0), \mathbf{Q̂, R̂}``.
 """
-KalmanFilter(model, i_ym, nint_u, nint_ym, P̂0, Q̂, R̂)
+function KalmanFilter(model::SM, i_ym, nint_u, nint_ym, P̂0, Q̂, R̂) where {NT<:Real, SM<:LinModel{NT}}
+    return KalmanFilter{NT, SM}(model, i_ym, nint_u, nint_ym, P̂0, Q̂ , R̂)
+end
 
 @doc raw"""
     update_estimate!(estim::KalmanFilter, u, ym, d)
@@ -366,7 +371,7 @@ struct UnscentedKalmanFilter{NT<:Real, SM<:SimModel} <: StateEstimator{NT}
         nx̂  = model.nx + nxs
         Â, B̂u, Ĉ, B̂d, D̂d = augment_model(model, As, Cs_u, Cs_y)
         validate_kfcov(nym, nx̂, Q̂, R̂, P̂0)
-        nσ, γ, m̂, Ŝ = init_ukf(nx̂, α, β, κ)
+        nσ, γ, m̂, Ŝ = init_ukf(model, nx̂, α, β, κ)
         lastu0 = zeros(NT, model.nu)
         x̂ = [zeros(NT, model.nx); zeros(NT, nxs)]
         Q̂, R̂ = Hermitian(Q̂, :L),  Hermitian(R̂, :L)
@@ -459,17 +464,21 @@ function UnscentedKalmanFilter(
 end
 
 @doc raw"""
-    UnscentedKalmanFilter{SM<:SimModel}(model::SM, i_ym, nint_u, nint_ym, P̂0, Q̂, R̂, α, β, κ)
+    UnscentedKalmanFilter(model, i_ym, nint_u, nint_ym, P̂0, Q̂, R̂, α, β, κ)
 
 Construct the estimator from the augmented covariance matrices `P̂0`, `Q̂` and `R̂`.
 
 This syntax allows nonzero off-diagonal elements in ``\mathbf{P̂}_{-1}(0), \mathbf{Q̂, R̂}``.
 """
-UnscentedKalmanFilter{SM}(model::SM, i_ym, nint_u, nint_ym, P̂0, Q̂, R̂, α, β, κ) where {SM<:SimModel}
+function UnscentedKalmanFilter(
+    model::SM, i_ym, nint_u, nint_ym, P̂0, Q̂, R̂, α, β, κ
+) where {NT<:Real, SM<:SimModel{NT}}
+    return UnscentedKalmanFilter{NT, SM}(model, i_ym, nint_u, nint_ym, P̂0, Q̂ , R̂, α, β, κ)
+end
 
 
 @doc raw"""
-    init_ukf(nx̂, α, β, κ) -> nσ, γ, m̂, Ŝ
+    init_ukf(model, nx̂, α, β, κ) -> nσ, γ, m̂, Ŝ
 
 Compute the [`UnscentedKalmanFilter`](@ref) constants from ``α, β`` and ``κ``.
 
@@ -489,14 +498,14 @@ covariance are respectively:
 ```
 See [`update_estimate!(::UnscentedKalmanFilter)`](@ref) for other details.
 """
-function init_ukf(nx̂, α, β, κ)
+function init_ukf(::SimModel{NT}, nx̂, α, β, κ) where {NT<:Real}
     nσ = 2nx̂ + 1                                  # number of sigma points
     γ = α * √(nx̂ + κ)                             # constant factor of standard deviation √P
     m̂_0 = 1 - nx̂ / γ^2
     Ŝ_0 = m̂_0 + 1 - α^2 + β
     w = 1 / 2 / γ^2
-    m̂ = [m̂_0; fill(w, 2 * nx̂)]                    # weights for the mean
-    Ŝ = Diagonal([Ŝ_0; fill(w, 2 * nx̂)]) # weights for the covariance
+    m̂ = NT[m̂_0; fill(w, 2 * nx̂)]                  # weights for the mean
+    Ŝ = Diagonal(NT[Ŝ_0; fill(w, 2 * nx̂)])        # weights for the covariance
     return nσ, γ, m̂, Ŝ
 end
 
@@ -678,13 +687,16 @@ function ExtendedKalmanFilter(
 end
 
 @doc raw"""
-    ExtendedKalmanFilter{SM<:SimModel}(model::SM, i_ym, nint_u, nint_ym, P̂0, Q̂, R̂)
+    ExtendedKalmanFilter(model, i_ym, nint_u, nint_ym, P̂0, Q̂, R̂)
 
 Construct the estimator from the augmented covariance matrices `P̂0`, `Q̂` and `R̂`.
 
 This syntax allows nonzero off-diagonal elements in ``\mathbf{P̂}_{-1}(0), \mathbf{Q̂, R̂}``.
 """
-ExtendedKalmanFilter{SM}(model::SM, i_ym, nint_u, nint_ym, P̂0, Q̂, R̂) where {SM<:SimModel}
+function ExtendedKalmanFilter(model::SM, i_ym, nint_u, nint_ym,P̂0, Q̂, R̂) where {NT<:Real, SM<:SimModel{NT}}
+    return ExtendedKalmanFilter{NT, SM}(model, i_ym, nint_u, nint_ym, P̂0, Q̂ , R̂)
+end
+
 
 @doc raw"""
     update_estimate!(estim::ExtendedKalmanFilter, u, ym, d=empty(estim.x̂))

src/model/linearization.jl

@@ -3,7 +3,6 @@
     LinModel(model::NonLinModel; x=model.x, u=model.uop, d=model.dop)
 
 Call [`linearize(model; x, u, d)`](@ref) and return the resulting linear model.
-```
 """
 LinModel(model::NonLinModel; kwargs...) = linearize(model; kwargs...)
 

src/model/linmodel.jl

@@ -205,7 +205,7 @@ function LinModel(
     Dd::Matrix{<:Real},
     Ts::Real
 )
-    A, Bu, C, Bd, Dd, Ts_arr = promote(A, Bu, C, Bd, Dd, [Ts;;])
+    A, Bu, C, Bd, Dd, Ts_arr = promote(A, Bu, C, Bd, Dd, Ts*ones(1,1))
     return LinModel(A, Bu, C, Bd, Dd, Ts_arr[])
 end
 

src/precompile_calls.jl

@@ -1,5 +1,3 @@
-#=
-
 sys = [ 
     tf(1.90, [18, 1]) tf(1.90, [18, 1]);
     tf(-0.74,[8, 1])  tf(0.74, [8, 1]) 
@@ -87,4 +85,3 @@ end
 empc = setconstraint!(NonLinMPC(nlmodel, Mwt=[0, 0], Hp=10, Cwt=Inf, Ewt=1, JE=JE), ymin=[45, -Inf])
 u = empc()
 sim!(empc, 3)
-=#

src/predictive_control.jl

@@ -753,9 +753,10 @@ are calculated by:
 ```
 """
 function init_ΔUtoU(nu, Hp, Hc)
-    S_Hc = LowerTriangular(repeat(I(nu), Hc, Hc))
-    S = [S_Hc; repeat(I(nu), Hp - Hc, Hc)]
-    T = repeat(I(nu), Hp)
+    I_nu = BitMatrix(I(nu))
+    S_Hc = LowerTriangular(repeat(I_nu, Hc, Hc))
+    S = [S_Hc; repeat(I_nu, Hp - Hc, Hc)]
+    T = repeat(I_nu, Hp)
     return S, T
 end
 
@@ -834,7 +835,7 @@ For the terminal constraints, the matrices are computed with the function
 \end{aligned}
 ```
 """
-function init_predmat(estim::StateEstimator, model::LinModel{NT}, Hp, Hc) where {NT<:Real}
+function init_predmat(estim::StateEstimator{NT}, model::LinModel, Hp, Hc) where {NT<:Real}
     Â, B̂u, Ĉ, B̂d, D̂d = estim.Â, estim.B̂u, estim.Ĉ, estim.B̂d, estim.D̂d
     nu, nx̂, ny, nd = model.nu, estim.nx̂, model.ny, model.nd
     # --- pre-compute matrix powers ---
@@ -893,7 +894,7 @@ function init_predmat(estim::StateEstimator, model::LinModel{NT}, Hp, Hc) where
 end
 
 "Return empty matrices if `model` is not a [`LinModel`](@ref)"
-function init_predmat(estim::StateEstimator, model::SimModel{NT}, Hp, Hc) where {NT<:Real}
+function init_predmat(estim::StateEstimator{NT}, model::SimModel, Hp, Hc) where {NT<:Real}
     nu, nx̂, nd = model.nu, estim.nx̂, model.nd
     E  = zeros(NT, 0, nu*Hc)
     G  = zeros(NT, 0, nd)
@@ -1025,8 +1026,8 @@ function init_defaultcon(
         repeat_constraints(Hp, Hc, umin, umax, Δumin, Δumax, ymin, ymax)
     C_umin, C_umax, C_Δumin, C_Δumax, C_ymin, C_ymax = 
         repeat_constraints(Hp, Hc, c_umin, c_umax, c_Δumin, c_Δumax, c_ymin, c_ymax)
-    A_Umin, A_Umax, S̃ = relaxU(C, C_umin, C_umax, S)
-    A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, Ñ_Hc = relaxΔU(C, C_Δumin, C_Δumax, ΔUmin, ΔUmax, N_Hc)
+    A_Umin, A_Umax, S̃ = relaxU(model, C, C_umin, C_umax, S)
+    A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, Ñ_Hc = relaxΔU(model, C, C_Δumin, C_Δumax, ΔUmin, ΔUmax, N_Hc)
     A_Ymin, A_Ymax, Ẽ = relaxŶ(model, C, C_ymin, C_ymax, E)
     A_x̂min, A_x̂max, ẽx̂ = relaxterminal(model, C, c_x̂min, c_x̂max, ex̂)
     i_Umin,  i_Umax  = .!isinf.(Umin),  .!isinf.(Umax)
@@ -1060,7 +1061,7 @@ function repeat_constraints(Hp, Hc, umin, umax, Δumin, Δumax, ymin, ymax)
 end
 
 @doc raw"""
-    relaxU(C, C_umin, C_umax, S) -> A_Umin, A_Umax, S̃
+    relaxU(model, C, C_umin, C_umax, S) -> A_Umin, A_Umax, S̃
 
 Augment manipulated inputs constraints with slack variable ϵ for softening.
 
@@ -1080,21 +1081,24 @@ constraints:
 \end{bmatrix}
 ```
 """
-function relaxU(C, C_umin, C_umax, S)
+function relaxU(::SimModel{NT}, C, C_umin, C_umax, S) where {NT<:Real}
+    S_NT = convert(Matrix{NT}, S)
     if !isinf(C) # ΔŨ = [ΔU; ϵ]
         # ϵ impacts ΔU → U conversion for constraint calculations:
-        A_Umin, A_Umax = -[S  C_umin],  [S -C_umax] 
+        A_Umin, A_Umax = -[S_NT  C_umin], [S_NT -C_umax] 
         # ϵ has no impact on ΔU → U conversion for prediction calculations:
         S̃ = [S falses(size(S, 1))]
     else # ΔŨ = ΔU (only hard constraints)
-        A_Umin, A_Umax = -S,  S
+        A_Umin, A_Umax = -S_NT,  S_NT
         S̃ = S
     end
     return A_Umin, A_Umax, S̃
 end
 
 @doc raw"""
-    relaxΔU(C, C_Δumin, C_Δumax, ΔUmin, ΔUmax, N_Hc) -> A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, Ñ_Hc
+    relaxΔU(
+        model, C, C_Δumin, C_Δumax, ΔUmin, ΔUmax, N_Hc
+    ) -> A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, Ñ_Hc
 
 Augment input increments constraints with slack variable ϵ for softening.
 
@@ -1114,18 +1118,19 @@ returns the augmented constraints ``\mathbf{ΔŨ_{min}}`` and ``\mathbf{ΔŨ_{
 \end{bmatrix}
 ```
 """
-function relaxΔU(C::NT, C_Δumin, C_Δumax, ΔUmin, ΔUmax, N_Hc) where {NT<:Real}
+function relaxΔU(::SimModel{NT}, C, C_Δumin, C_Δumax, ΔUmin, ΔUmax, N_Hc) where {NT<:Real}
+    diag_N_Hc = diag(N_Hc)
     if !isinf(C) # ΔŨ = [ΔU; ϵ]
         # 0 ≤ ϵ ≤ ∞  
-        ΔŨmin, ΔŨmax = [ΔUmin; 0.0], [ΔUmax; Inf]
-        A_ϵ = [zeros(NT, 1, length(ΔUmin)) [1.0]]
+        ΔŨmin, ΔŨmax = [ΔUmin; NT[0.0]], [ΔUmax; NT[Inf]]
+        A_ϵ = [zeros(NT, 1, length(ΔUmin)) NT[1.0]]
         A_ΔŨmin, A_ΔŨmax = -[I  C_Δumin; A_ϵ], [I -C_Δumax; A_ϵ]
-        Ñ_Hc = Diagonal([diag(N_Hc); C])
+        Ñ_Hc = Diagonal{NT}([diag_N_Hc; C])
     else # ΔŨ = ΔU (only hard constraints)
         ΔŨmin, ΔŨmax = ΔUmin, ΔUmax
         I_Hc = Matrix{NT}(I, size(N_Hc))
         A_ΔŨmin, A_ΔŨmax = -I_Hc,  I_Hc
-        Ñ_Hc = N_Hc
+        Ñ_Hc = Diagonal{NT}(diag_N_Hc)
     end
     return A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, Ñ_Hc
 end

test/test_predictive_control.jl

@@ -32,7 +32,7 @@ sys = [ tf(1.90,[18.0,1])   tf(1.90,[18.0,1])   tf(1.90,[18.0,1]);
     @test mpc11.Ñ_Hc ≈ Diagonal([0.1,0.11,0.12,0.13])
     mcp12 = LinMPC(model, L_Hp=Diagonal(collect(0.001:0.001:0.02)))
     @test mcp12.L_Hp ≈ Diagonal(collect(0.001:0.001:0.02))
-    model2 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    model2 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     mpc13  = LinMPC(model2)
     @test isa(mpc13, LinMPC{Float32})
     @test isa(mpc13.optim, JuMP.GenericModel{Float64}) # OSQP does not support Float32
@@ -67,7 +67,7 @@ end
     mpc3 = LinMPC(linmodel, Mwt=[0], Nwt=[0], Lwt=[1])
     u = moveinput!(mpc3, [0], R̂u=fill(12, mpc3.Hp))
     @test u ≈ [12] atol=1e-2
-    model2 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    model2 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     mpc4  = LinMPC(model2)
     moveinput!(mpc4, [0]) ≈ [0.0]
 
@@ -255,7 +255,7 @@ end
     @test mpc11.Ñ_Hc ≈ Diagonal([0.1,0.11,0.12,0.13])
     mcp12 = ExplicitMPC(model, L_Hp=Diagonal(collect(0.001:0.001:0.02)))
     @test mcp12.L_Hp ≈ Diagonal(collect(0.001:0.001:0.02))
-    model2 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    model2 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     mpc13  = ExplicitMPC(model2)
     @test isa(mpc13, ExplicitMPC{Float32})
 end
@@ -276,7 +276,7 @@ end
     mpc3 = ExplicitMPC(LinModel(tf(5, [2, 1]), 3), Mwt=[0], Nwt=[0], Lwt=[1])
     u = moveinput!(mpc3, [0], R̂u=fill(12, mpc3.Hp))
     @test u ≈ [12] atol=1e-2
-    model2 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    model2 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     mpc4  = ExplicitMPC(model2)
     moveinput!(mpc4, [0]) ≈ [0.0]
 end
@@ -434,7 +434,7 @@ end
     @test g_Ymax_end((1.0, 1.0)) ≤ 0.0 # test gfunc_i(i,::NTuple{N, Float64})
     # test gfunc_i(i,::NTuple{N, ForwardDiff.Dual}) : 
     @test ForwardDiff.gradient(g_Ymax_end, [1.0, 1.0]) ≈ [0.0, 0.0]
-    linmodel3 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    linmodel3 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     nmpc6  = NonLinMPC(linmodel3, Hp=10)
     moveinput!(nmpc6, [0]) ≈ [0.0]
     nonlinmodel2 = NonLinModel{Float32}(f, h, 300.0, 1, 2, 1, 1)

test/test_state_estim.jl

@@ -44,10 +44,14 @@ sys = [ tf(1.90,[18.0,1])   tf(1.90,[18.0,1])   tf(1.90,[18.0,1]);
     @test skalmanfilter7.nint_u  == [1, 1]
     @test skalmanfilter7.nint_ym == [0, 0]
 
-    linmodel2 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    linmodel2 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     skalmanfilter8 = SteadyKalmanFilter(linmodel2)
     @test isa(skalmanfilter8, SteadyKalmanFilter{Float32})
 
+    skalmanfilter9 = SteadyKalmanFilter(linmodel1, 1:2, 0, [1, 1], I(4), I(2))
+    @test skalmanfilter9.Q̂ ≈ I(4)
+    @test skalmanfilter9.R̂ ≈ I(2)
+
     @test_throws ErrorException SteadyKalmanFilter(linmodel1, nint_ym=[1,1,1])
     @test_throws ErrorException SteadyKalmanFilter(linmodel1, nint_ym=[-1,0])
     @test_throws ErrorException SteadyKalmanFilter(linmodel1, nint_ym=0, σQ=[1])
@@ -134,7 +138,12 @@ end
     @test kalmanfilter7.nint_u  == [1, 1]
     @test kalmanfilter7.nint_ym == [0, 0]
 
-    linmodel2 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    kalmanfilter8 = KalmanFilter(linmodel1, 1:2, 0, [1, 1], I(4), I(4), I(2))
+    @test kalmanfilter8.P̂0 ≈ I(4)
+    @test kalmanfilter8.Q̂ ≈ I(4)
+    @test kalmanfilter8.R̂ ≈ I(2)
+
+    linmodel2 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     kalmanfilter8 = KalmanFilter(linmodel2)
     @test isa(kalmanfilter8, KalmanFilter{Float32})
 
@@ -201,7 +210,7 @@ end
     @test lo5.nint_u  == [1, 1]
     @test lo5.nint_ym == [0, 0]
 
-    linmodel2 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    linmodel2 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     lo6 = Luenberger(linmodel2)
     @test isa(lo6, Luenberger{Float32})
 
@@ -299,7 +308,7 @@ end
     @test internalmodel7.Cs ≈ stoch_ym_disc.C
     @test internalmodel7.Ds ≈ stoch_ym_disc.D
 
-    linmodel3 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    linmodel3 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     internalmodel8 = InternalModel(linmodel3)
     @test isa(internalmodel8, InternalModel{Float32})
 
@@ -379,7 +388,12 @@ end
     @test ukf8.nint_u  == [1, 1]
     @test ukf8.nint_ym == [0, 0]
 
-    linmodel2 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    ukf9 = UnscentedKalmanFilter(nonlinmodel, 1:2, 0, [1, 1], I(6), I(6), I(2), 0.1, 2, 0)
+    @test ukf9.P̂0 ≈ I(6)
+    @test ukf9.Q̂ ≈ I(6)
+    @test ukf9.R̂ ≈ I(2)
+
+    linmodel2 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     ukf9 = UnscentedKalmanFilter(linmodel2)
     @test isa(ukf9, UnscentedKalmanFilter{Float32})
 end
@@ -460,7 +474,12 @@ end
     @test ekf7.nint_u  == [1, 1]
     @test ekf7.nint_ym == [0, 0]
 
-    linmodel2 = LinModel{Float32}([0.5;;], [1;;], [1;;], zeros(1,0), zeros(1,0), 1.0)
+    ekf8 = ExtendedKalmanFilter(nonlinmodel, 1:2, 0, [1, 1], I(6), I(6), I(2))
+    @test ekf8.P̂0 ≈ I(6)
+    @test ekf8.Q̂ ≈ I(6)
+    @test ekf8.R̂ ≈ I(2)
+
+    linmodel2 = LinModel{Float32}(0.5*ones(1,1), ones(1,1), ones(1,1), zeros(1,0), zeros(1,0), 1.0)
     ekf8 = ExtendedKalmanFilter(linmodel2)
     @test isa(ekf8, ExtendedKalmanFilter{Float32})
 end