work on hvcat macro

Author: mfalt

.travis.yml

@@ -7,7 +7,7 @@ script:
     - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
     - julia -e 'Pkg.clone(pwd()); Pkg.build("ControlSystems")'
     #- julia -e 'ENV["PYTHON"] = ""; Pkg.clone("PyPlot"); Pkg.build("PyPlot")'
-    - julia -e 'Pkg.clone("https://github.com/JuliaControl/ControlExamplePlots.jl.git");'
+    #- julia -e 'Pkg.clone("https://github.com/JuliaControl/ControlExamplePlots.jl.git");'
     - julia -e 'Pkg.test("ControlSystems"; coverage=true)'
 after_success:
     - julia -e 'cd(Pkg.dir("ControlSystems")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'

src/connections.jl

@@ -43,7 +43,15 @@ end
 
 append(systems::LTISystem...) = append(promote(systems...)...)
 
-function Base.vcat(systems::StateSpace...)
+macro sys(ex)
+    if ex.head == :vcat
+        # vcat or hvcat
+    elseif ex.head == :hcat
+        # hcat only
+    end
+end
+
+function vcatsys(systems::StateSpace...)
     # Perform checks
     nu = systems[1].nu
     if !all(s.nu == nu for s in systems)
@@ -61,7 +69,7 @@ function Base.vcat(systems::StateSpace...)
     return StateSpace(A, B, C, D, Ts)
 end
 
-function Base.vcat(systems::TransferFunction...)
+function vcatsys(systems::TransferFunction...)
     # Perform checks
     nu = systems[1].nu
     if !all(s.nu == nu for s in systems)
@@ -75,17 +83,17 @@ function Base.vcat(systems::TransferFunction...)
     return TransferFunction(mat, Ts)
 end
 
-Base.vcat(systems::LTISystem...) = vcat(promote(systems...)...)
+vcatsys(systems::LTISystem...) = vcat(promote(systems...)...)
 
-function Base.vcat{T<:Real}(systems::Union{VecOrMat{T},T,TransferFunction}...)
+function vcatsys{T<:Real}(systems::Union{VecOrMat{T},T,TransferFunction}...)
     if Base.promote_typeof(systems...) <: TransferFunction
         vcat(map(e->convert(TransferFunction,e),systems)...)
     else
         cat(1,systems...)
     end
 end
 
-function Base.hcat(systems::StateSpace...)
+function hcatsys(systems::StateSpace...)
     # Perform checks
     ny = systems[1].ny
     if !all(s.ny == ny for s in systems)
@@ -103,7 +111,7 @@ function Base.hcat(systems::StateSpace...)
     return StateSpace(A, B, C, D, Ts)
 end
 
-function Base.hcat(systems::TransferFunction...)
+function hcatsys(systems::TransferFunction...)
     # Perform checks
     ny = systems[1].ny
     if !all(s.ny == ny for s in systems)
@@ -117,30 +125,30 @@ function Base.hcat(systems::TransferFunction...)
     return TransferFunction(mat, Ts)
 end
 
-Base.hcat(systems::LTISystem...) = hcat(promote(systems...)...)
+hcatsys(systems::LTISystem...) = hcat(promote(systems...)...)
 
 
 # TODO: Fix this
-function Base.hcat(systems::Union{Number,AbstractVecOrMat{<:Number},LTISystem}...)
+function hcatsys(systems::Union{Number,AbstractVecOrMat{<:Number},LTISystem}...)
     S = Base.promote_typeof(systems...)
     if S <: LTISystem
-        hcat(map(e->convert(S,e),systems)...)
+        hcatsys(map(e->convert(S,e),systems)...)
     else
         cat(Val{2},systems...)
     end
 end
 
 
-function Base.hvcat(rows::Tuple{Vararg{Int}}, systems::Union{Number,AbstractVecOrMat{<:Number},LTISystem}...)
+function hvcatsys(rows::Tuple{Vararg{Int}}, systems::Union{Number,AbstractVecOrMat{<:Number},LTISystem}...)
     T = Base.promote_typeof(systems...)
     nbr = length(rows)  # number of block rows
     rs = Array{T,1}(nbr)
     a = 1
     for i = 1:nbr
-        rs[i] = hcat(convert.(T,systems[a:a-1+rows[i]])...)
+        rs[i] = hcatsys(convert.(T,systems[a:a-1+rows[i]])...)
         a += rows[i]
     end
-    vcat(rs...)
+    vcatsys(rs...)
 end
 
 # function _get_common_sampling_time(sys_vec::Union{AbstractVector{LTISystem},AbstractVecOrMat{<:Number},Number})

src/types/SisoTfTypes/SisoZpk.jl

@@ -25,7 +25,7 @@ function SisoZpk{T}(z::Vector, p::Vector, k::Number) where T
     SisoZpk{T,TR}(Vector{TR}(z), Vector{TR}(p), T(k))
 end
 function SisoZpk(z::AbstractVector{TZ}, p::AbstractVector{TP}, k::T) where {T<:Number, TZ<:Number, TP<:Number} # NOTE: is this constructor really needed?
-    TR = promote_type(TZ,TP,T)
+    TR = promote_type(TZ,TP)
     # Could check if complex roots come with their conjugates,
     # i.e., if the SisoZpk corresponds to a real-valued system
 
@@ -50,8 +50,8 @@ Base.zero(f::SisoZpk) = zero(typeof(f))
 
 
 # tzero is not meaningful for transfer function element? But both zero and zeros are taken...
-tzero(sys::SisoZpk) = f.z # Do minreal first?,
-pole(sys::SisoZpk) = f.p # Do minreal first?
+tzero(f::SisoZpk) = f.z # Do minreal first?,
+pole(f::SisoZpk) = f.p # Do minreal first?
 
 numpoly(f::SisoZpk{<:Real}) = f.k*prod(roots2real_poly_factors(f.z))
 denpoly(f::SisoZpk{<:Real}) = prod(roots2real_poly_factors(f.p))
@@ -198,14 +198,19 @@ end
 function +(f1::SisoZpk{T1,TR1}, f2::SisoZpk{T2,TR2}) where {T1<:Number,T2<:Number,TR1<:Number,TR2<:Number}
     numPoly = numpoly(f1)*denpoly(f2) + numpoly(f2)*denpoly(f1)
 
-    TR = promote_type(TR1, TR2)
-    z = convert(Vector{TR}, roots(numPoly))
+    TRtmp = promote_type(TR1, TR2)
+    # Calculating roots can make integers floats
+    TRnew = Base.promote_op(/, TRtmp, TRtmp)
+    z = convert(Vector{TRnew}, roots(numPoly))
+    #TODO gains could remain integers, but numerical precision inhibits this
+    Ttmp = promote_type(T1,T2)
+    Tnew = Base.promote_op(/, Ttmp, Ttmp)
     if length(numPoly) > 0
-        k = numPoly[end]
-        p = convert(Vector{TR}, [f1.p;f2.p])
+        k = convert(Tnew, numPoly[end])
+        p = convert(Vector{TRnew}, [f1.p;f2.p])
     else
-        k = 0
-        p = TR[]
+        k = zero(Tnew)
+        p = TRnew[]
     end
 
     # FIXME:
@@ -231,6 +236,7 @@ end
 
 
 *(f1::SisoZpk, f2::SisoZpk) = SisoZpk([f1.z;f2.z], [f1.p;f2.p], f1.k*f2.k)
+
 *(f::SisoZpk, n::Number) = SisoZpk(f.z, f.p, f.k*n)
 *(n::Number, f::SisoZpk) = *(f, n)
 #.*(f1::SisoZpk, f2::SisoZpk) = *(f1, f2)

src/types/SisoTfTypes/promotion.jl

@@ -16,5 +16,3 @@ function Base.promote_rule(::Type{SisoZpk{T1,TR1}}, ::Type{T2}) where {T1<:Numbe
     # TODO Not obvious that we want to promote to complex poles?
     SisoZpk{Tnew, TRnew}
 end
-
-Base.promote_op(::Any, ::Type{T}, ::Type{T}) where {T<:SisoTf} = T

src/types/TransferFunction.jl

@@ -122,7 +122,6 @@ function +(G1::TransferFunction, G2::TransferFunction)
         error("Sampling time mismatch")
     end
 
-    G1, G2 = promote(G1, G2)
     matrix = G1.matrix + G2.matrix
     return TransferFunction(matrix, G1.Ts)
 end
@@ -146,15 +145,10 @@ function *(G1::TransferFunction, G2::TransferFunction)
     elseif G1.Ts != G2.Ts
         error("Sampling time mismatch")
     end
-    S = promote_type(eltype(G1), eltype(G2)) # FIXME: Should be done analogusly to +
-
-    #matrix = convert(Matrix{S}, G1.matrix) * convert(Matrix{S}, G2.matrix)
-    G1, G2 = promote(G1, G2)
 
     matrix = G1.matrix * G2.matrix
-    convert(Matrix{S}, matrix)
 
-    return TransferFunction{S}(matrix, G1.Ts)
+    return TransferFunction{eltype(matrix)}(matrix, G1.Ts)
 end
 
 *(G::TransferFunction, n::Number) = TransferFunction(n*G.matrix, G.Ts)

test/runtests.jl

@@ -10,6 +10,7 @@ my_tests = ["test_statespace",
             "test_connections",
             "test_discrete",
             "test_conversion",
+            "test_complex",
             "test_linalg",
             "test_simplification",
             "test_freqresp",

test/test_complex.jl

@@ -0,0 +1,31 @@
+@testset "test_complex_systems" begin
+
+C_1 = zpk([], [-1+im], 1.0+1im)
+C_2 = zpk([-1+im], [], 1.0+1im)
+
+# Basic arittmetic
+@test C_1 + C_1 == zpk([], [-1+im], 2+2im)
+@test (1.0+im)*C_1 == zpk([], [-1+im], 2.0im)
+@test C_2 + C_2 == zpk([-1+im], [], 2+2im)
+
+@test C_1 * C_1 == zpk([], [-1+im,-1+im], 2.0im)
+@test C_2 * C_2 ≈ zpk([-1+im,-1+im], [], 2.0im)
+
+
+@test pole(zpk([], [-1+im,-1+im,0], 2.0im)) == [-1+im,-1+im,0]
+@test tzero(zpk([-1+im,-1+im,0], [-2], 2.0im)) == [-1+im,-1+im,0]
+
+@test zpk( tf([1.0, 1+im], [1.0, 2+im]) ) == zpk( [-1-im], [-2-im], 1.0+0im)
+
+@test minreal(zpk([-1+im], [-1+im,-1+im],1+0im)) == zpk([], [-1+im],1+0im)
+@test minreal(zpk([-1+im, -1+im], [-1+im],1+1im)) == zpk([-1+im], [], 1+1im)
+
+
+@test_throws AssertionError zpk([-1+im], [-1+im,-1+im],1) #  Given the type of k this should be a real-coefficient system, but poles and zeros don't come in conjugate pairs
+
+@test zpk([-2+im], [-1+im],1+0im)*zpk([], [-1+im],1+0im) == zpk([-2+im], [-1+im, -1+im], 1+0im)
+@test zpk([], [-2], 2) + zpk([], [-1], 1) == zpk([-4/3], [-2,-1], 3)
+
+@test_broken tf(zpk([-2+im], [-1+im],1+0im))
+
+end