type fixes

Author: baggepinnen

Project.toml

@@ -1,7 +1,7 @@
 name = "RobustAndOptimalControl"
 uuid = "21fd56a4-db03-40ee-82ee-a87907bee541"
 authors = ["Fredrik Bagge Carlson", "Marcus Greiff"]
-version = "0.2.2"
+version = "0.2.3"
 
 [deps]
 ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"

src/ExtendedStateSpace.jl

@@ -295,7 +295,7 @@ end
 #####################################################################
 Base.ndims(::ExtendedStateSpace) = 2 # NOTE: Also for SISO systems?
 Base.size(sys::ExtendedStateSpace) = (noutputs(sys), ninputs(sys)) # NOTE: or just size(sys.D)
-Base.size(sys::ExtendedStateSpace, d) = d <= 2 ? size(sys)[d] : 1
+Base.size(sys::ExtendedStateSpace, d::Integer) = d <= 2 ? size(sys)[d] : 1
 Base.eltype(::Type{S}) where {S<:ExtendedStateSpace} = S
 ControlSystems.numeric_type(sys::ExtendedStateSpace) = eltype(sys.A)
 
@@ -354,7 +354,7 @@ function ControlSystems.lft(G::ExtendedStateSpace, Δ, type=:l)
     # end
 
     if type === :l
-        feedback(G, Δ)
+        lft(ss(G), Δ, :l)
     else
         error("Invalid type of lft ($type), specify type=:l")
     end

src/named_systems2.jl

@@ -120,18 +120,18 @@ fb = feedback(s1, s2, r = :r) #
 """
 function named_ss(sys::AbstractStateSpace{T};
     x = [Symbol("x$i") for i in 1:sys.nx],
-    u = [Symbol("u$i") for i in 1:sys.nu],
-    y = [Symbol("y$i") for i in 1:sys.ny],
+    u = [Symbol("u$i") for i in 1:size(sys,2)], # sinze is used instead of sys.nu for ExtendedStateSpace
+    y = [Symbol("y$i") for i in 1:size(sys,1)],
     ) where T
     x = expand_symbol(x, sys.nx)
-    u = expand_symbol(u, sys.nu)
-    y = expand_symbol(y, sys.ny)
+    u = expand_symbol(u, size(sys,2))
+    y = expand_symbol(y, size(sys,1))
     length(x) == sys.nx ||
-        throw(ArgumentError("Length of state names must match sys.nx ($(sys.nx))"))
-    length(u) == sys.nu ||
-        throw(ArgumentError("Length of input names must match sys.nu ($(sys.nu))"))
-    length(y) == sys.ny ||
-        throw(ArgumentError("Length of output names must match sys.ny ($(sys.ny))"))
+        throw(ArgumentError("Length of state names must match sys.nx ($(sys.nx)), got length $(length(x))"))
+    length(u) == size(sys,2) ||
+        throw(ArgumentError("Length of input names must match size(sys,2) ($(size(sys,2))), got length $(length(u))"))
+    length(y) == size(sys,1) ||
+        throw(ArgumentError("Length of output names must match size(sys,1) ($(size(sys,1))), got length $(length(y))"))
 
     @check_unique x "x"
     @check_unique u "u"

src/uncertainty_interface.jl

@@ -49,7 +49,7 @@ function Base.promote_rule(::Type{N}, ::Type{δ{C, F}}) where {N <: Number, F, C
     δ{promote_type(N, C), promote_type(N, F)}
 end
 
-Base.convert(::Type{δ{C, F}}, n::Number) where {C,F} = δ(n, 0.0)
+Base.convert(::Type{δ{C, F}}, n::Number) where {C,F} = δ(C(n), zero(F))
 Base.convert(::Type{δ{C, F}}, d::δ) where {C,F} = δ(C(d.val), F(d.radius), d.name)
 
 #  + and - we define here, all other ops generate ExtendedStateSpace. THis is to avoid creating a complicated tagging mechanism
@@ -140,16 +140,16 @@ for f in [:system_mapping, :performance_mapping, :ss]
     @eval $f(s::UncertainSS, args...; kwargs...) = $f(s.sys, args...; kwargs...)
 end
 
-function Base.promote_rule(::Type{U}, ::Type{δ{C, F}}) where {U <: UncertainSS, F, C}
-    UncertainSS
+function Base.promote_rule(::Type{UncertainSS{TE}}, ::Type{δ{C, F}}) where {TE, F, C}
+    UncertainSS{TE}
 end
 
-function Base.promote_rule(::Type{U}, ::Type{L}) where {U <: UncertainSS, L <: LTISystem}
-    UncertainSS
+function Base.promote_rule(::Type{UncertainSS{TE}}, ::Type{L}) where {TE, L <: LTISystem}
+    UncertainSS{TE}
 end
 
-function Base.promote_rule(::Type{U}, ::Type{L}) where {U <: UncertainSS, L <: AbstractArray}
-    UncertainSS
+function Base.promote_rule(::Type{UncertainSS{TE}}, ::Type{L}) where {TE, L <: AbstractArray}
+    UncertainSS{TE}
 end
 
 function Base.convert(::Type{U}, d::δ) where {U <: UncertainSS}
@@ -206,8 +206,12 @@ Create a diagonal uncertain statespace object with the uncertain elements `d` on
 function uss(d::AbstractVector{<:δ}, Ts = nothing)
     vals = getfield.(d, :val)
     rads = getfield.(d, :radius)
+    nonzero = rads .> 0
+    # vals = vals
+    # rads = rads
+    nd = count(nonzero)
     n = length(d)
-    uss(0I(n), I(n), diagm(rads), diagm(vals), normalize.(d), Ts)
+    uss(0I(nd), I(n)[nonzero, :], diagm(rads)[:, nonzero], diagm(vals), normalize.(d[nonzero]), Ts)
 end
 
 uss(n::Number, Ts=nothing) = uss(zeros(0,0), zeros(0,1), zeros(1,0), 1, [], Ts)
@@ -336,11 +340,12 @@ function ControlSystems.lft(G::UncertainSS, Δ::AbstractArray=G.Δ, type=:u)
 end
 
 function ControlSystems.lft(G::UncertainSS, K::LTISystem, type=:l)
-    if type !== :l
-        error("Invalid type of lft ($type), specify type=:l")
+    if type === :u
+        sys = lft(ss(G.sys), ss(K), :u)
     else
+        nu1, ny1 = G.nw, G.nz
         sys = lft(ss(G.sys), ss(K), :l)
-        sys = partition(sys, sys.nu, sys.nu)
+        sys = partition(sys, nu1, ny1)
         UncertainSS(sys, G.Δ)
     end
 end

test/test_reduction.jl

@@ -67,7 +67,7 @@ D = [10.0 0.0; 0.0 10.0]
 WT = ss(A, B, C, D)
 P = hinfpartition(G, WS, WU, WT)
 
-flag, C, γ = hinfsynthesize(P)
+flag, C, γ = hinfsynthesize(P, γrel=1)
 
 Pcl, S, CS, T = hinfsignals(P, G, C)