Fix deprecations

Author: femtocleaner[bot]

src/analysis.jl

@@ -221,7 +221,7 @@ If `!allMargins`, return only the smallest margin
 If `full` return also `fullPhase`
 
 """
-function margin{S<:Real}(sys::LTISystem, w::AbstractVector{S}; full=false, allMargins=false)
+function margin(sys::LTISystem, w::AbstractVector{S}; full=false, allMargins=false) where S<:Real
     ny, nu = size(sys)
     vals = (:wgm, :gm, :wpm, :pm, :fullPhase)
     if allMargins
@@ -250,7 +250,7 @@ end
 
 returns frequencies for gain margins, gain margins, frequencies for phase margins, phase margins
 """
-function sisomargin{S<:Real}(sys::LTISystem, w::AbstractVector{S}; full=false, allMargins=false)
+function sisomargin(sys::LTISystem, w::AbstractVector{S}; full=false, allMargins=false) where S<:Real
     ny, nu = size(sys)
     if ny !=1 || nu != 1
         error("System must be SISO, use `margin` instead")

src/discrete.jl

@@ -206,8 +206,8 @@ a zero vector is used.
 Continuous time systems are discretized before simulation. By default, the
 method is chosen based on the smoothness of the input signal. Optionally, the
 `method` parameter can be specified as either `:zoh` or `:foh`.""" ->
-function lsima{T}(sys::StateSpace, t::AbstractVector, r::AbstractVector{T}, control_signal::Function,state,
-    x0::VecOrMat=zeros(sys.nx, 1), method::Symbol=:zoh)
+function lsima(sys::StateSpace, t::AbstractVector, r::AbstractVector{T}, control_signal::Function,state,
+    x0::VecOrMat=zeros(sys.nx, 1), method::Symbol=:zoh) where T
     ny, nu = size(sys)
 
     nx = sys.nx

src/freqresp.jl

@@ -158,7 +158,7 @@ function sigma(sys::LTISystem, w::AbstractVector)
 end
 sigma(sys::LTISystem) = sigma(sys, _default_freq_vector(sys, :sigma))
 
-function _default_freq_vector{T<:LTISystem}(systems::Vector{T}, plot::Symbol)
+function _default_freq_vector(systems::Vector{T}, plot::Symbol) where T<:LTISystem
     min_pt_per_dec = 60
     min_pt_total = 200
     nsys = length(systems)

src/matrix_comps.jl

@@ -412,7 +412,7 @@ function balance(A, perm::Bool=true)
     return S, P, B
 end
 
-function cswap!{T<:Number}(i::Integer, j::Integer, X::StridedMatrix{T})
+function cswap!(i::Integer, j::Integer, X::StridedMatrix{T}) where T<:Number
     for k = 1:size(X,1)
         X[i, k], X[j, k] = X[j, k], X[i, k]
     end

src/plotting.jl

@@ -111,7 +111,7 @@ lsimplot
         styledict = getStyleSys(si,length(systems))
         seriestype := iscontinuous(s) ? :path : :steppost
         for i=1:ny
-            ytext = (ny > 1) ? "Amplitude to: y($i)": "Amplitude"
+            ytext = (ny > 1) ? "Amplitude to: y($i)" : "Amplitude"
             @series begin
                 xguide  --> "Time (s)"
                 yguide  --> ytext
@@ -176,7 +176,7 @@ for (func, title, typ) = ((step, "Step Response", Stepplot), (impulse, "Impulse
                     style = iscontinuous(s) ? :path : :steppost
                     ttext = (nu > 1 && i==1) ? title*" from: u($j) " : title
                     titles[s2i(i,j)] = ttext
-                    ytext = (ny > 1 && j==1) ? "Amplitude to: y($i)": "Amplitude"
+                    ytext = (ny > 1 && j==1) ? "Amplitude to: y($i)" : "Amplitude"
                     @series begin
                         seriestype := style
                         xlabel --> "Time (s)"
@@ -219,8 +219,8 @@ bodeplot
         error("All systems must have the same input/output dimensions")
     end
     ny, nu = size(systems[1])
-    s2i(i,j) = sub2ind((nu,(plotphase?2:1)*ny),j,i)
-    layout --> ((plotphase?2:1)*ny,nu)
+    s2i(i,j) = sub2ind((nu,(plotphase ? 2 : 1)*ny),j,i)
+    layout --> ((plotphase ? 2 : 1)*ny,nu)
     nw = length(w)
     xticks --> getLogTicks(w)
 
@@ -250,7 +250,7 @@ bodeplot
                     end
                     xguide    --> xlab
                     yguide    --> "Magnitude $_PlotScaleStr"
-                    subplot --> s2i((plotphase?(2i-1):i),j)
+                    subplot --> s2i((plotphase ? (2i-1) : i),j)
                     title     --> "Bode plot from: u($j)"
                     label     --> "\$G_\{$(si)\}\$"
                     linestyle --> styledict[:l]
@@ -558,7 +558,7 @@ nicholsplot
 
 end
 
-nicholsplot{T<:LTISystem}(systems::Vector{T};kwargs...) =
+nicholsplot(systems::Vector{T};kwargs...) where {T<:LTISystem} =
 nicholsplot(systems, _default_freq_vector(systems, :nyquist);kwargs...)
 nicholsplot(sys::LTISystem, args...; kwargs...) = nicholsplot([sys],args...; kwargs...)
 
@@ -597,7 +597,7 @@ sigmaplot
         end
     end
 end
-sigmaplot{T<:LTISystem}(systems::Vector{T}; kwargs...) =
+sigmaplot(systems::Vector{T}; kwargs...) where {T<:LTISystem} =
 sigmaplot(systems, _default_freq_vector(systems, :sigma); kwargs...)
 sigmaplot(sys::LTISystem, args...; kwargs...) = sigmaplot([sys], args...; kwargs...)
 
@@ -607,7 +607,7 @@ Plot all the amplitude and phase margins of the system(s) `sys`.
 A frequency vector `w` can be optionally provided.
 
 `kwargs` is sent as argument to Plots.plot.""" ->
-function marginplot{T<:LTISystem}(systems::Vector{T}, w::AbstractVector; kwargs...)
+function marginplot(systems::Vector{T}, w::AbstractVector; kwargs...) where T<:LTISystem
     if !_same_io_dims(systems...)
         error("All systems must have the same input/output dimensions")
     end
@@ -657,7 +657,7 @@ function marginplot{T<:LTISystem}(systems::Vector{T}, w::AbstractVector; kwargs.
     end
     return fig
 end
-marginplot{T<:LTISystem}(systems::Vector{T}; kwargs...) =
+marginplot(systems::Vector{T}; kwargs...) where {T<:LTISystem} =
 marginplot(systems, _default_freq_vector(systems, :bode); kwargs...)
 marginplot(sys::LTISystem, args...; kwargs...) = marginplot([sys], args...; kwargs...)
 
@@ -669,7 +669,7 @@ function _same_io_dims(systems::LTISystem...)
     return all(s -> s == sizes[1], sizes)
 end
 
-function _default_time_data{T<:LTISystem}(systems::Vector{T})
+function _default_time_data(systems::Vector{T}) where T<:LTISystem
     sample_times = [_default_Ts(i) for i in systems]
     Tf = 100*maximum(sample_times)
     return sample_times, Tf

src/synthesis.jl

@@ -149,7 +149,7 @@ feedback(L::TransferFunction) = L/(1+L)
 feedback(P1::TransferFunction, P2::TransferFunction) = P1/(1+P1*P2)
 
 #Efficient implementations
-function feedback{T<:SisoRational}(L::TransferFunction{T})
+function feedback(L::TransferFunction{T}) where T<:SisoRational
     if size(L) != (1,1)
         error("MIMO TransferFunction inversion isn't implemented yet")
     end

src/timeresp.jl

@@ -184,8 +184,8 @@ If `x0` is not provided, a zero-vector is used.
 
 If `u` is a function, then `u(x,i)` is called to calculate the control signal every iteration. This can be used to provide a control law such as state feedback `u=-Lx` calculated by `lqr`. In this case, an integrer `iters` must be provided that indicates the number of iterations.
 """ ->
-function ltitr{T}(A::Matrix{T}, B::Matrix{T}, u::AbstractVecOrMat{T},
-        x0::VecOrMat{T}=zeros(T, size(A, 1)))
+function ltitr(A::Matrix{T}, B::Matrix{T}, u::AbstractVecOrMat{T},
+        x0::VecOrMat{T}=zeros(T, size(A, 1))) where T
     n = size(u, 1)
     x = Array{T}(size(A, 1), n)
     for i=1:n
@@ -196,8 +196,8 @@ function ltitr{T}(A::Matrix{T}, B::Matrix{T}, u::AbstractVecOrMat{T},
 end
 
 
-function ltitr{T}(A::Matrix{T}, B::Matrix{T}, u::Function, t,
-    x0::VecOrMat{T}=zeros(T, size(A, 1)))
+function ltitr(A::Matrix{T}, B::Matrix{T}, u::Function, t,
+    x0::VecOrMat{T}=zeros(T, size(A, 1))) where T
     iters = length(t)
     x = Array{T}(size(A, 1), iters)
     uout = Array{T}(size(B, 2), iters)

src/types/TransferFunction.jl

@@ -1,4 +1,4 @@
-type TransferFunction{S<:SisoTf{T} where T} <: LTISystem
+mutable struct TransferFunction{S<:SisoTf{T} where T} <: LTISystem
     matrix::Matrix{S}
     Ts::Float64
     nu::Int
@@ -110,7 +110,7 @@ function isapprox(G1::TransferFunction, G2::TransferFunction; kwargs...)
     return true
 end
 
-function isapprox{T<:SisoTf, S<:SisoTf}(G1::Array{T}, G2::Array{S}; kwargs...)
+function isapprox(G1::Array{T}, G2::Array{S}; kwargs...) where {T<:SisoTf, S<:SisoTf}
     reduce(&, [isapprox(G1[i], G2[i]; kwargs...) for i in eachindex(G1)])
 end
 

src/utilities.jl

@@ -106,6 +106,6 @@ outs = index2range(ind1, ind2)
 Helper function to convert indexes with scalars to ranges. Used to avoid dropping dimensions
 """
 index2range(ind1, ind2) = (index2range(ind1), index2range(ind2))
-index2range{T<:Number}(ind::T) = ind:ind
-index2range{T<:AbstractArray}(ind::T) = ind
+index2range(ind::T) where {T<:Number} = ind:ind
+index2range(ind::T) where {T<:AbstractArray} = ind
 index2range(ind::Colon) = ind

test/framework.jl

@@ -48,7 +48,7 @@ function vecarray(T::Type, ny::Int,nx::Int, args::AbstractArray...)
     array = reshape(collect(Array{T,1},args),nx,ny)
     permutedims(array,[2,1])
 end
-vecarray{T}(ny::Int,nx::Int, args::AbstractArray{T}...) = vecarray(T, ny, nx, args...)
+vecarray(ny::Int,nx::Int, args::AbstractArray{T}...) where {T} = vecarray(T, ny, nx, args...)
 
 function vecarray(ny::Int,nx::Int, args::AbstractArray...)
     args2 = promote(args...)