Updates to work with julia 0.5 (#84)

* Updates to work with julia 0.5

* Updated version in travis, and minor typo

* Tests pass even if ControlExamplePlots is missing

* Minor depwarn fix

Author: mfalt

.travis.yml

@@ -1,6 +1,6 @@
 language: julia
 julia:
-  - 0.4
+  - 0.5
 notifications:
     email: false
 script:

REQUIRE

@@ -1,3 +1,3 @@
-julia 0.4
+julia 0.5-
 Plots v0.7.4
 Polynomials

src/ControlSystems.jl

@@ -63,7 +63,7 @@ export  LTISystem,
         denpoly
 
 import Plots
-import Base: +, -, *, /, (./), (==), (.+), (.-), (.*), (!=), isapprox, call, convert
+import Base: +, -, *, /, (./), (==), (.+), (.-), (.*), (!=), isapprox, call, convert, promote_op
 
 include("types/lti.jl")
 include("types/transferfunction.jl")

src/connections.jl

@@ -72,7 +72,7 @@ function Base.vcat(systems::StateSpace...)
     outputs = vcat([s.outputnames for s in systems]...)
     inputs = systems[1].inputnames
     if !all([s.inputnames == inputs for s in systems])
-        inputs = fill(UTF8String(""),size(inputs, 1))
+        inputs = fill(String(""),size(inputs, 1))
     end
     return StateSpace(A, B, C, D, Ts, states, inputs, outputs)
 end
@@ -91,7 +91,7 @@ function Base.vcat(systems::TransferFunction...)
     outputs = vcat([s.outputnames for s in systems]...)
     inputs = systems[1].inputnames
     if !all([s.inputnames == inputs for s in systems])
-        inputs = fill(UTF8String(""),size(inputs, 1))
+        inputs = fill(String(""),size(inputs, 1))
     end
     return TransferFunction(mat, Ts, inputs, outputs)
 end
@@ -124,7 +124,7 @@ function Base.hcat(systems::StateSpace...)
     inputs = vcat([s.inputnames for s in systems]...)
     outputs = systems[1].outputnames
     if !all([s.outputnames == outputs for s in systems])
-        outputs = fill(UTF8String(""),size(outputs, 1))
+        outputs = fill(String(""),size(outputs, 1))
     end
     return StateSpace(A, B, C, D, Ts, states, inputs, outputs)
 end
@@ -143,7 +143,7 @@ function Base.hcat(systems::TransferFunction...)
     inputs = vcat([s.inputnames for s in systems]...)
     outputs = systems[1].outputnames
     if !all([s.outputnames == outputs for s in systems])
-        outputs = fill(UTF8String(""),size(outputs, 1))
+        outputs = fill(String(""),size(outputs, 1))
     end
     return TransferFunction(mat, Ts, inputs, outputs)
 end

src/freqresp.jl

@@ -85,11 +85,11 @@ Notation for frequency response evaluation.
 - F(omega,true) evaluates the discrete-time transfer function F at i*Ts*omega
 - F(z,false) evaluates the discrete-time transfer function F at z
 """ ->
-function Base.call(sys::TransferFunction, s)
+function (sys::TransferFunction)(s)
     evalfr(sys,s)
 end
 
-function Base.call(sys::TransferFunction, z_or_omega::Number, map_to_unit_circle::Bool)
+function (sys::TransferFunction)(z_or_omega::Number, map_to_unit_circle::Bool)
     @assert !iscontinuous(sys) "It makes no sense to call this function with continuous systems"
     if map_to_unit_circle
         isreal(z_or_omega) ? evalfr(sys,exp(im*z_or_omega.*sys.Ts)) : error("To map to the unit circle, omega should be real")
@@ -98,7 +98,7 @@ function Base.call(sys::TransferFunction, z_or_omega::Number, map_to_unit_circle
     end
 end
 
-function Base.call(sys::TransferFunction, s::AbstractVector, map_to_unit_circle::Bool)
+function (sys::TransferFunction)(s::AbstractVector, map_to_unit_circle::Bool)
     @assert !iscontinuous(sys) "It makes no sense to call this function with continuous systems"
     freqresp(sys,s)
 end
@@ -138,7 +138,7 @@ function sigma(sys::LTISystem, w::AbstractVector)
     nw, ny, nu = size(resp)
     sv = Array(Float64, nw, min(ny, nu))
     for i=1:nw
-        sv[i, :] = svdvals(squeeze(resp[i, :, :],(1)))
+        sv[i, :] = svdvals(resp[i, :, :])
     end
     return sv, w
 end

src/matrix_comps.jl

@@ -284,7 +284,7 @@ Compute a similarity transform `T` resulting in `B = T\\A*T` such that the row
 and column norms of `B` are approximately equivalent. If `perm=false`, the
 transformation will only scale, and not permute `A`.""" ->
 function balance(A, perm::Bool=true)
-    n = Base.LinAlg.chksquare(A)
+    n = Base.LinAlg.checksquare(A)
     B = copy(A)
     job = perm ? 'B' : 'S'
     ilo, ihi, scaling = LAPACK.gebal!(job, B)

src/plotting.jl

@@ -82,7 +82,7 @@ for (func, title) = ((:step, "Step Response"), (:impulse, "Impulse Response"))
             end
             ny, nu = size(systems[1])
             fig = Plots.plot(layout=(ny,nu))
-            titles = fill("", ny*nu)
+            titles = fill("", 1, ny*nu)
             s2i(i,j) = sub2ind((ny,nu),j,i)
             for (si,(s, Ts)) in enumerate(zip(systems, Ts_list))
                 t = 0:Ts:Tf
@@ -98,7 +98,7 @@ for (func, title) = ((:step, "Step Response"), (:impulse, "Impulse Response"))
                     end
                 end
             end
-            Plots.plot!(fig, title=titles')
+            Plots.plot!(fig, title=titles)
             return fig
         end
         $funcname{T<:LTISystem}(systems::Vector{T}, Tf::Real; kwargs...) =

src/types/statespace.jl

@@ -11,14 +11,14 @@ type StateSpace <: LTISystem
     nx::Int
     nu::Int
     ny::Int
-    statenames::Vector{UTF8String}
-    inputnames::Vector{UTF8String}
-    outputnames::Vector{UTF8String}
+    statenames::Vector{String}
+    inputnames::Vector{String}
+    outputnames::Vector{String}
 
     function StateSpace(A::Matrix{Float64}, B::Matrix{Float64},
             C::Matrix{Float64}, D::Matrix{Float64}, Ts::Float64,
-            statenames::Vector{UTF8String}, inputnames::Vector{UTF8String},
-            outputnames::Vector{UTF8String})
+            statenames::Vector{String}, inputnames::Vector{String},
+            outputnames::Vector{String})
         nx = size(A, 1)
         nu = size(B, 2)
         ny = size(C, 1)
@@ -52,8 +52,8 @@ type StateSpace <: LTISystem
 end
 
 function StateSpace(A::Array, B::Array, C::Array, D::Array, Ts::Real,
-        statenames::Vector{UTF8String}, inputnames::Vector{UTF8String},
-        outputnames::Vector{UTF8String})
+        statenames::Vector{String}, inputnames::Vector{String},
+        outputnames::Vector{String})
     return StateSpace(float64mat(A), float64mat(B), float64mat(C),
             float64mat(D), map(Float64, Ts), statenames, inputnames, outputnames)
 end
@@ -182,14 +182,14 @@ function +(s1::StateSpace, s2::StateSpace)
     elseif all(s2.inputnames .== "") || (s1.inputnames == s2.inputnames)
         inputnames = s1.inputnames
     else
-        inputnames = fill(UTF8String(""),s1.ny)
+        inputnames = fill(String(""),s1.ny)
     end
     if all(s1.outputnames .== "")
         outputnames = s2.outputnames
     elseif all(s2.outputnames .== "") || (s1.outputnames == s2.outputnames)
         outputnames = s1.outputnames
     else
-        outputnames = fill(UTF8String(""),s1.nu)
+        outputnames = fill(String(""),s1.nu)
     end
     return StateSpace(A, B, C, D, s1.Ts, statenames, inputnames, outputnames)
 end
@@ -260,7 +260,7 @@ function Base.getindex(s::StateSpace, inds...)
     if size(inds, 1) != 2
         error("Must specify 2 indices to index statespace model")
     end
-    rows, cols = inds
+    rows, cols = ControlSystems.index2range(inds...)
     return StateSpace([s.A;], [s.B[:, cols];], [s.C[rows, :];], [s.D[rows, cols];],
             s.Ts, [s.statenames;], [s.inputnames[cols];], [s.outputnames[rows];])
 end
@@ -270,11 +270,11 @@ end
 #####################################################################
 
 # TODO : this is a very hacky way of handling StateSpace printing.
-function _string_mat_with_headers(X::Matrix, cols::Vector{UTF8String},
-                                rows::Vector{UTF8String})
-    mat = [[""] cols';
+function _string_mat_with_headers(X::Matrix, cols::Vector{String},
+                                rows::Vector{String})
+    mat = [[""] reshape(cols,1,length(cols));
            rows X]
-    p = (io, m) -> Base.showarray(io, m, header=false, repr=false)
+    p = (io, m) -> Base.showarray(io, m, false, header=false)
     return replace(sprint(p, mat), "\"", " ")
 end
 

src/types/tf2ss.jl

@@ -145,7 +145,7 @@ function ss2tf(A, B, C, D, Ts = 0; inputnames = "", outputnames = "")
     ubernum = Matrix{Vector}(ny,nu)
     uberden = Matrix{Vector}(ny,nu)
     for i = 1:nu, j=1:ny
-        ubernum[j,i],uberden[j,i] = sisoss2tf(A, B[:,i], C[j,:], D[j,i])
+        ubernum[j,i],uberden[j,i] = sisoss2tf(A, B[:,i], C[j,:]', D[j,i])
     end
     tf(ubernum,uberden, Ts, inputnames=inputnames, outputnames=outputnames)
 end

src/types/transferfunction.jl

@@ -12,10 +12,10 @@ type TransferFunction{S<:SisoTf} <: LTISystem
     Ts::Float64
     nu::Int
     ny::Int
-    inputnames::Vector{UTF8String}
-    outputnames::Vector{UTF8String}
+    inputnames::Vector{String}
+    outputnames::Vector{String}
     function TransferFunction{T<:SisoTf}(matrix::Matrix{T}, Ts::Float64,
-            inputnames::Vector{UTF8String}, outputnames::Vector{UTF8String})
+            inputnames::Vector{String}, outputnames::Vector{String})
         # Validate size of input and output names
         ny, nu = size(matrix)
         if size(inputnames, 1) != nu
@@ -81,7 +81,6 @@ Base.convert(::Type{SisoGeneralized}, sys::SisoZpk) = convert(SisoGeneralized, c
 
 Base.convert(::Type{SisoRational}, sys::SisoGeneralized) = SisoRational(sys.expr)
 Base.convert(::Type{SisoZpk}, sys::SisoGeneralized) = convert(SisoZpk, SisoRational(sys.expr))
-Base.convert(::Type{TransferFunction{SisoZpk}}, s::TransferFunction) = zpk(s)
 
 #Just default SisoTf to SisoRational
 SisoTf(args...) = SisoRational(args...)
@@ -116,6 +115,10 @@ tzero(sys::SisoTf) = error("tzero is not implemented for type $(typeof(sys))")
 ==(a::SisoTf, b::SisoTf) = ==(promote(a,b)...)
 !=(a::SisoTf, b::SisoTf) = !(a==b)
 isapprox(a::SisoTf, b::SisoTf; kwargs...) = isapprox(promote(a,b)...; kwargs...)
+
+# Promote_op types
+Base.promote_op{T<:SisoTf}(::Any, ::Type{T}, ::Type{T}) = T
+
 #####################################################################
 ##                      Constructor Functions                      ##
 #####################################################################
@@ -319,11 +322,11 @@ function Base.getindex(t::TransferFunction, inds...)
     if size(inds, 1) != 2
         error("Must specify 2 indices to index TransferFunction model")
     end
-    rows, cols = inds
+    rows, cols = ControlSystems.index2range(inds...)
     mat = Array(eltype(t.matrix), length(rows), length(cols))
     mat[:, :] = t.matrix[rows, cols]
-    innames = UTF8String[t.inputnames[i] for i in cols]
-    outnames = UTF8String[t.outputnames[i] for i in rows]
+    innames = String[t.inputnames[i] for i in cols]
+    outnames = String[t.outputnames[i] for i in rows]
     return TransferFunction(mat, t.Ts, innames, outnames)
 end
 
@@ -397,14 +400,14 @@ function +(t1::TransferFunction, t2::TransferFunction)
     elseif all(t2.inputnames .== "") || (t1.inputnames == t2.inputnames)
         inputnames = t1.inputnames
     else
-        inputnames = fill(UTF8String(""),t1.ny)
+        inputnames = fill(String(""),t1.ny)
     end
     if all(t1.outputnames .== "")
         outputnames = t2.outputnames
     elseif all(t2.outputnames .== "") || (t1.outputnames == t2.outputnames)
         outputnames = t1.outputnames
     else
-        outputnames = fill(UTF8String(""),t1.nu)
+        outputnames = fill(String(""),t1.nu)
     end
     t1, t2 = promote(t1, t2)
     matrix = t1.matrix + t2.matrix