diff --git a/Project.toml b/Project.toml
new file mode 100644
index 0000000..b6529f6
--- /dev/null
+++ b/Project.toml
@@ -0,0 +1,23 @@
+name = "ControlToolbox"
+uuid = "059e8e86-8a00-5752-9d3d-adbce60f63dd"
+authors = ["Arda Aytekin <aytekin@kth.se>, Niklas Everitt <neveritt@kth.se>"]
+
+[deps]
+Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
+LTISystems = "67f030dc-aa52-5f83-ac42-e4024659685c"
+MathProgBase = "fdba3010-5040-5b88-9595-932c9decdf73"
+Optim = "429524aa-4258-5aef-a3af-852621145aeb"
+
+[compat]
+Compat = "≥ 0.17.0"
+LTISystems = "≥ 0.1.0"
+MathProgBase = "≥ 0.6.0"
+NLopt = "≥ 0.3.5"
+Optim = "≥ 0.7.8"
+julia = "≥ 0.5.0"
+
+[extras]
+NLopt = "76087f3c-5699-56af-9a33-bf431cd00edd"
+
+[targets]
+test = ["NLopt"]
diff --git a/src/ControlToolbox.jl b/src/ControlToolbox.jl
index 959b9bb..3a0da3e 100644
--- a/src/ControlToolbox.jl
+++ b/src/ControlToolbox.jl
@@ -1,15 +1,18 @@
 module ControlToolbox
 
 using Compat
+using LinearAlgebra
 using Optim
 using Polynomials
+using Printf
 using RationalFunctions
 using RecipesBase
 using LTISystems
 
-import Base: step, norm
-import Base.LinAlg: BlasFloat
-import Base: start, next, done
+import Base: step
+#import Base: BlasFloat
+import Base: iterate
+import LinearAlgebra: norm
 import LTISystems: LtiSystem, StateSpace, TransferFunction, SystemResponse
 import MathProgBase: eval_grad_f, eval_f, eval_g, features_available, initialize
 
diff --git a/src/analysis/damp.jl b/src/analysis/damp.jl
index 2aa8d74..d1e565e 100644
--- a/src/analysis/damp.jl
+++ b/src/analysis/damp.jl
@@ -4,7 +4,7 @@
 Compute the natural frequencies, `Wn`, and damping ratios, `zeta`, of the
 poles, `ps`, of `sys`
 """
-function damp{T,S}(sys::LtiSystem{T,S})
+function damp(sys::LtiSystem{T,S}) where {T,S}
   ps = poles(sys)
   if isdiscrete(sys)
     #Ts = sys.Ts == -1 ? 1 : sys.Ts
@@ -26,7 +26,7 @@ constant of the system `sys`
 """
 function dampreport(io::IO, sys::LtiSystem)
     Wn, zeta, ps = damp(sys)
-    t_const = 1./(Wn.*zeta)
+    t_const = 1 ./(Wn.*zeta)
     header =
     ("|     Pole                        |   Damping     |   Frequency   | Time Constant |\n"*
      "|                                 |    Ratio      |   (rad/sec)   |     (sec)     |\n"*
diff --git a/src/analysis/isstable.jl b/src/analysis/isstable.jl
index 62643a0..ba69f85 100644
--- a/src/analysis/isstable.jl
+++ b/src/analysis/isstable.jl
@@ -1,7 +1,7 @@
 
-isstable{S}(s::StateSpace{S,Val{:disc}}) = maximum(abs(poles(s))) < 1
+isstable(s::StateSpace{S,Val{:disc}}) where {S} = maximum(abs(poles(s))) < 1
 
-isstable{S}(s::StateSpace{S,Val{:cont}}) = maximum(real(poles(s))) < 0
+isstable(s::StateSpace{S,Val{:cont}}) where {S} = maximum(real(poles(s))) < 0
 
 #isstable(s::LtiSystem{Val{:mimo}}) = map(isstable, getmatrix(s))
 
diff --git a/src/analysis/margins.jl b/src/analysis/margins.jl
index e484dca..1084368 100644
--- a/src/analysis/margins.jl
+++ b/src/analysis/margins.jl
@@ -64,7 +64,7 @@ gainmargin(sys::LtiSystem, dB::Bool=false) = gainmargin(tf(sys), dB=dB)
 
 
 # Compute the real and imaginary parts of a polynomial assuming the argument is complex (=jw)
-function polysplit{T<:Real}(p::Poly{T})
+function polysplit(p::Poly{T}) where {T<:Real}
   rp = copy(coeffs(p))
   ip = copy(rp)
 
diff --git a/src/analysis/rootlocus.jl b/src/analysis/rootlocus.jl
index 62ba131..be65851 100644
--- a/src/analysis/rootlocus.jl
+++ b/src/analysis/rootlocus.jl
@@ -1,4 +1,4 @@
-type RootLocusResponse{T} <: SystemResponse
+mutable struct RootLocusResponse{T} <: SystemResponse
   K::Vector{T}        # gains
   systf::TransferFunction{Val{:siso}}
   real_p::Matrix{T}   # real part of poles
@@ -8,9 +8,9 @@ type RootLocusResponse{T} <: SystemResponse
   d0::T               # radius
   tloc::Int
 
-  function (::Type{RootLocusResponse}){S<:Real,U<:Real,V<:Real}(
-    K::Vector{S}, systf::TransferFunction{Val{:siso}}, real_p::Matrix{U},
-    imag_p::Matrix{V}, real_m0::Real, imag_m0::Real, d0::Real)
+  function (::Type{RootLocusResponse})(K::Vector{S},
+    systf::TransferFunction{Val{:siso}}, real_p::Matrix{U}, imag_p::Matrix{V},
+    real_m0::Real, imag_m0::Real, d0::Real) where {S<:Real,U<:Real,V<:Real}
     if size(real_p) != size(imag_p)
       warn("RootLocusResponse: mag and phase must have same dimensions")
       throw(DomainError())
@@ -40,9 +40,8 @@ type RootLocusResponse{T} <: SystemResponse
 end
 
 # Iteration interface
-start(rls::RootLocusResponse)       = (rls.tloc = 1)
-done(rls::RootLocusResponse, state) = state >= length(rls.K)
-next(rls::RootLocusResponse, state) = (state+=1; rls.tloc = state; (rls, state))
+iterate(rls::RootLocusResponse)        = begin rls.tloc = 1; (rls, 1) end
+iterate(rls::RootLocusResponse, state) = state >= length(rls.K) ? nothing : (state+=1; rls.tloc = state; (rls, state))
 
 # Plot some outputs for some inputs
 @recipe function f(rls::RootLocusResponse)
@@ -134,14 +133,14 @@ julia> sys = tf([2., 5, 1], [1., 2, 3]);
 
 julia> rl = rootlocus(sys);
 """
-function rootlocus{S}(sys::LtiSystem{Val{:siso}}, K::AbstractVector{S}=Float64[];
-  kwargs...)
+function rootlocus(sys::LtiSystem{Val{:siso}}, K::AbstractVector{S}=Float64[];
+  kwargs...) where {S}
   systf = tf(sys)
   rootlocus(systf, K; kwargs...)
 end
 
-function rootlocus{S<:Real}(systf::TransferFunction{Val{:siso}},
-  K::AbstractVector{S}=Float64[]; N::Int=100)
+function rootlocus(systf::TransferFunction{Val{:siso}},
+  K::AbstractVector{S}=Float64[]; N::Int=100) where {S<:Real}
   r  = systf.mat[1]
   nump = num(r)
   denp = den(r)
diff --git a/src/c2d.jl b/src/c2d.jl
index edf2c0c..862bf03 100644
--- a/src/c2d.jl
+++ b/src/c2d.jl
@@ -8,7 +8,7 @@ using LTISystems: LtiSystem, StateSpace, TransferFunction
 @compat abstract type Method end
 
 # Zero-Order-Hold
-immutable ZOH <: Method
+struct ZOH <: Method
 end
 
 @compat function (m::ZOH)(A::AbstractMatrix, B::AbstractMatrix, C::AbstractMatrix,
@@ -32,13 +32,13 @@ end
   Ad, Bd, Cd, Dd, Ts, x0map = m(s.A, s.B, s.C, s.D, Ts)
   ss(Ad, Bd, Cd, Dd, Ts), x0map
 end
-@compat (m::ZOH){T}(s::TransferFunction{Val{T},Val{:cont}}, Ts::Real) =
+@compat (m::ZOH)(s::TransferFunction{Val{T},Val{:cont}}, Ts::Real) where {T} =
   tf(m(ss(s), Ts)[1])
-@compat (m::ZOH){T}(s::LtiSystem{Val{T},Val{:cont}}, Ts::Real)  =
+@compat (m::ZOH)(s::LtiSystem{Val{T},Val{:cont}}, Ts::Real) where {T} =
   m(ss(s), Ts)[1]
 
 # First-Order-Hold
-immutable FOH <: Method
+struct FOH <: Method
 end
 
 @compat function (m::FOH)(A::AbstractMatrix, B::AbstractMatrix, C::AbstractMatrix,
@@ -65,15 +65,15 @@ end
   Ad, Bd, Cd, Dd, Ts, x0map = m(s.A, s.B, s.C, s.D, Ts)
   ss(Ad, Bd, Cd, Dd, Ts), x0map
 end
-@compat (m::FOH){T}(s::TransferFunction{Val{T},Val{:cont}}, Ts::Real) =
+@compat (m::FOH)(s::TransferFunction{Val{T},Val{:cont}}, Ts::Real) where {T} =
   tf(m(ss(s), Ts)[1])
-@compat (m::FOH){T}(s::LtiSystem{Val{T},Val{:cont}}, Ts::Real)  =
+@compat (m::FOH)(s::LtiSystem{Val{T},Val{:cont}}, Ts::Real) where {T} =
   m(ss(s), Ts)[1]
 
 # Generalized Bilinear Transformation
-immutable Bilinear{T<:Real} <: Method
+struct Bilinear{T<:Real} <: Method
   α::T
-  @compat function (::Type{Bilinear}){T}(α::T = 0.5)
+  @compat function (::Type{Bilinear})(α::T = 0.5) where {T}
     @assert α ≥ 0. && α ≤ 1. "Bilinear: α must be between 0 and 1"
     new{T}(α)
   end
@@ -87,7 +87,7 @@ end
   ima   = I - α*Ts*A
   Ad    = ima\(I + (1.0-α)*Ts*A)
   Bd    = ima\(Ts*B)
-  Cd    = (ima.'\C.').'
+  Cd    = transpose(transpose(ima)\transpose(C))
   Dd    = D + α*(C*Bd)
   x0map = [speye(nx) spzeros(nx, nu)]
   Ad, Bd, Cd, Dd, Ts, x0map
@@ -100,13 +100,13 @@ end
   Ad, Bd, Cd, Dd, Ts, x0map = m(s.A, s.B, s.C, s.D, Ts)
   ss(Ad, Bd, Cd, Dd, Ts), x0map
 end
-@compat (m::Bilinear){T}(s::TransferFunction{Val{T},Val{:cont}}, Ts::Real)  =
+@compat (m::Bilinear)(s::TransferFunction{Val{T},Val{:cont}}, Ts::Real) where {T} =
   tf(m(ss(s), Ts)[1])
-@compat (m::Bilinear){T}(s::LtiSystem{Val{T},Val{:cont}}, Ts::Real)   =
+@compat (m::Bilinear)(s::LtiSystem{Val{T},Val{:cont}}, Ts::Real) where {T} =
   m(ss(s), Ts)[1]
 
 # Forward Euler
-immutable ForwardEuler <: Method
+struct ForwardEuler <: Method
 end
 
 @compat function (m::ForwardEuler)(A::AbstractMatrix, B::AbstractMatrix,
@@ -128,13 +128,13 @@ end
   Ad, Bd, Cd, Dd, Ts, x0map = m(s.A, s.B, s.C, s.D, Ts)
   ss(Ad, Bd, Cd, Dd, Ts), x0map
 end
-@compat (m::ForwardEuler){T}(s::TransferFunction{Val{T},Val{:cont}}, Ts::Real)  =
+@compat (m::ForwardEuler)(s::TransferFunction{Val{T},Val{:cont}}, Ts::Real) where {T} =
   tf(m(ss(s), Ts)[1])
-@compat (m::ForwardEuler){T}(s::LtiSystem{Val{T},Val{:cont}}, Ts::Real)   =
+@compat (m::ForwardEuler)(s::LtiSystem{Val{T},Val{:cont}}, Ts::Real) where {T} =
   m(ss(s), Ts)[1]
 
 # Backward Euler
-immutable BackwardEuler <: Method
+struct BackwardEuler <: Method
 end
 
 @compat function (m::BackwardEuler)(A::AbstractMatrix, B::AbstractMatrix,
@@ -144,7 +144,7 @@ end
   ima   = I - Ts*A
   Ad    = ima\eye(nx)
   Bd    = ima\(Ts*B)
-  Cd    = (ima.'\C.').'
+  Cd    = transpose(transpose(ima)\transpose(C))
   Dd    = D + C*Bd
   x0map = [speye(nx) spzeros(nx, nu)]
   Ad, Bd, Cd, Dd, Ts, x0map
@@ -157,9 +157,9 @@ end
   Ad, Bd, Cd, Dd, Ts, x0map = m(s, Ts)
   ss(Ad, Bd, Cd, Dd, Ts), x0map
 end
-@compat (m::BackwardEuler){T}(s::TransferFunction{Val{T},Val{:cont}}, Ts::Real)  =
+@compat (m::BackwardEuler)(s::TransferFunction{Val{T},Val{:cont}}, Ts::Real) where {T} =
   tf(m(ss(s), Ts)[1])
-@compat (m::BackwardEuler){T}(s::LtiSystem{Val{T},Val{:cont}}, Ts::Real)   =
+@compat (m::BackwardEuler)(s::LtiSystem{Val{T},Val{:cont}}, Ts::Real) where {T} =
   m(ss(s), Ts)[1]
 
 end
@@ -199,15 +199,15 @@ The generalized bilinear transform uses the parameter α and is based on [1].
 - [1] G. Zhang, X. Chen, and T. Chen, Digital redesign via the generalized
       bilinear transformation, Int. J. Control, vol. 82, no. 4, pp. 741-754, 2009.
 """
-function c2d{T}(s::StateSpace{T,Val{:cont}}, Ts::Real,
-  method = Discretization.ZOH())
+function c2d(s::StateSpace{T,Val{:cont}}, Ts::Real,
+  method = Discretization.ZOH()) where {T}
   @assert Ts > zero(Ts) && !isinf(Ts) "c2d: Ts must be a positive number"
   sys, x0map = method(s, Ts)
   return sys::StateSpace{T,Val{:disc}}, x0map::AbstractMatrix
 end
-function c2d{T}(s::LtiSystem{T,Val{:cont}}, Ts::Real,
-  method = Discretization.ZOH())
+function c2d(s::LtiSystem{T,Val{:cont}}, Ts::Real,
+  method = Discretization.ZOH()) where {T}
   @assert Ts > zero(Ts) && !isinf(Ts) "c2d: Ts must be a positive number"
   method(s, Ts)::LtiSystem{T,Val{:disc}}
 end
-c2d{T}(method::Function, s::LtiSystem{T,Val{:cont}}, Ts::Real) = c2d(s, Ts, method)
+c2d(method::Function, s::LtiSystem{T,Val{:cont}}, Ts::Real) where {T} = c2d(s, Ts, method)
diff --git a/src/d2c.jl b/src/d2c.jl
index 03a4eb3..bd1a9e3 100644
--- a/src/d2c.jl
+++ b/src/d2c.jl
@@ -4,7 +4,7 @@
 Recovers the continuous time which was sampled with a zero-order-hold to obtain
 the discrete time system `s`.
 """
-function d2c{S}(s::StateSpace{S,Val{:disc}})
+function d2c(s::StateSpace{S,Val{:disc}}) where {S}
   A, B, C, D = s.A, s.B, s.C, s.D
   for λ in eig(A)[1]
     println(λ)
@@ -23,4 +23,4 @@ function d2c{S}(s::StateSpace{S,Val{:disc}})
   ss(Ac, Bc, Cc, Dc)
 end
 
-d2c{S}(s::LtiSystem{S,Val{:disc}}) = d2c(ss(s))
+d2c(s::LtiSystem{S,Val{:disc}}) where {S} = d2c(ss(s))
diff --git a/src/design/place.jl b/src/design/place.jl
index 6fb7e23..bc6b789 100644
--- a/src/design/place.jl
+++ b/src/design/place.jl
@@ -57,34 +57,32 @@ Complex{Float64}[4]
         feedback parametrization." IEEE International Symposium on
         Computer-Aided Control System Design, 2000.
 """
-function place{S<:Real,U<:Real,V<:Number}(
-  A::AbstractArray{S, 2}, B::AbstractArray{U, 2}, p::AbstractArray{V, 1};
-  α::Real = 0.99, rtol::Real=1e-3, iter::Integer=200)
+function place(A::AbstractArray{S, 2}, B::AbstractArray{U, 2}, p::AbstractArray{V, 1};
+  α::Real = 0.99, rtol::Real=1e-3, iter::Integer=200) where {S<:Real,U<:Real,V<:Number}
 
   # define optimization problem
   d = Poleplacement(A, B, p; α=α, rtol=rtol)
 
-  if(size(A,1) - d.m  > 0) # if there is something to optimize over
-    df = OnceDifferentiable(x -> eval_f(d::Poleplacement, x),
-                           (x, grad_f) -> eval_grad_f(d::Poleplacement, grad_f, x))
+  if (size(A,1) - d.m > 0) # if there is something to optimize over
+    df = OnceDifferentiable(x -> eval_f(d::Poleplacement, x), (x, grad_f) -> eval_grad_f(d::Poleplacement, grad_f, x))
     res = optimize(df,
-                  rand(eltype(d.xₚ), length(d.xₚ)),
-                  Optim.BFGS(),
-                  Optim.Options(iterations = iter))
+                   rand(eltype(d.xₚ), length(d.xₚ)),
+                   Optim.BFGS(),
+                   Optim.Options(iterations = iter))
   end
+
   # transform controller according to the factorization of A
-  K = hcat(zeros(size(d.K,1), d.m), d.K)*d.Qₐ.'
+  K = hcat(zeros(size(d.K,1), d.m), d.K)*transpose(d.Qₐ)
 end
 
-function place{S<:Real,U<:Real,V<:Number}(
-  A::AbstractArray{S, 2}, B::AbstractArray{U, 2}, p::AbstractArray{V, 1},
-  solver::AbstractMathProgSolver;
-  α::Real = 0.99, rtol::Real=1e-3, iter::Integer=200)
+function place(A::AbstractArray{S, 2}, B::AbstractArray{U, 2},
+  p::AbstractArray{V, 1}, solver::AbstractMathProgSolver;
+  α::Real = 0.99, rtol::Real=1e-3, iter::Integer=200) where {S<:Real,U<:Real,V<:Number}
 
   # define optimization problem
   d = Poleplacement(A, B, p; α=α, rtol=rtol)
 
-  if(size(A,1) - d.m  > 0) # if there is something to optimize over
+  if (size(A,1) - d.m > 0)
     G0 = randn(size(A,1)-d.m, size(B,2)) # random initial point
     n = length(G0)
     l = -Inf*ones(n)
@@ -102,11 +100,11 @@ function place{S<:Real,U<:Real,V<:Number}(
       throw(InvalidStateException())
     end
   end
-  # transform controller according to the factorization of A
-  K = hcat(zeros(size(d.K,1), d.m), d.K)*d.Qₐ.'
+
+  K = hcat(zeros(size(d.K,1), d.m), d.K)*transpose(d.Qₐ)
 end
 
-type Poleplacement{T,M} <: AbstractNLPEvaluator
+mutable struct Poleplacement{T,M} <: AbstractNLPEvaluator
   K::M
   A::M
   B::M
@@ -118,9 +116,9 @@ type Poleplacement{T,M} <: AbstractNLPEvaluator
   m::Integer
   Qₐ::M
 
-  @compat function (::Type{Poleplacement}){S<:Real,U<:Real,V<:Number}(
-    A::AbstractArray{S, 2}, B::AbstractArray{U, 2}, p::AbstractArray{V, 1};
-    α::Real = 0.99, rtol::Real=1e-3)
+  @compat function (::Type{Poleplacement})(A::AbstractArray{S, 2},
+    B::AbstractArray{U, 2}, p::AbstractArray{V, 1}; α::Real = 0.99,
+    rtol::Real=1e-3) where {S<:Real,U<:Real,V<:Number}
     T = promote_type(eltype(A), eltype(B), real(eltype(p)), typeof(α), Float16)
     A = one(T)*A
     B = one(T)*B
@@ -134,14 +132,15 @@ type Poleplacement{T,M} <: AbstractNLPEvaluator
     end
 
     # schur factorization of A
-    Rₐ, Qₐ, λ = schur(A)
+    F = schur(A)
+    values = copy(F.values)
 
     # find eigenvalues not moved
     select = zeros(Bool, length(p))
     for i in eachindex(p)
-      j = findfirst(y->isapprox(p[i],y; rtol=rtol), λ)
-      if (j > 0)
-        splice!(λ, j)
+      j = findfirst(y->isapprox(p[i], y; rtol=rtol), values)
+      if (j != nothing)
+        splice!(values, j)
         select[i] = true
       end
     end
@@ -154,8 +153,10 @@ type Poleplacement{T,M} <: AbstractNLPEvaluator
     # form, i.e. in A₃
     # QₐᵀAQₐ = Rₐ =  [A₁ A₂;      QₐᵀB = QB = [B₁;
     #                 0  A₃]                   B₂]
-    ordschur!(Rₐ, Qₐ, select)
-    Qᵦ = Qₐ.'*B
+    ordschur!(F, select)
+    Rₐ, Qₐ, λ = F
+
+    Qᵦ = transpose(Qₐ)*B
     A₃ = Rₐ[m+1:end,m+1:end]
     B₂ = Qᵦ[m+1:end,:]
 
@@ -163,8 +164,8 @@ type Poleplacement{T,M} <: AbstractNLPEvaluator
     # of X, κ(X) according to cost function J = ακ(X) + (1-α)‖K‖²
     G  = randn(T,size(B₂,2),size(A₃,2))
     xₚ = randn(T,length(G))
-    X  = eye(T,size(A₃,1))
-    Xᵢ = eye(T,size(A₃,1))
+    X  = Matrix(Diagonal{T}(I,size(A₃,1)))
+    Xᵢ = Matrix(Diagonal{T}(I,size(A₃,1)))
     K  = zeros(T, size(G*Xᵢ))
 
     new{T,typeof(X)}(K, A₃, B₂, Ã, α, xₚ, X, Xᵢ, m, Qₐ)
@@ -177,10 +178,11 @@ function common_first_sylvester!(d::Poleplacement, x)
     d.xₚ[:] = x
     G = reshape(x, size(d.B,2), size(d.A,2))
     # solve AX - XÃ = -B*G
-    X, scale = LAPACK.trsyl!('N', 'N', d.A, d.Ã, -d.B*G, -1)
-    scale!(X, inv(scale)) # this scale is always 1?
-    d.X[:]  = X
-    d.Xᵢ[:] = inv(X)
+#    X, scale = LAPACK.trsyl!('N', 'N', d.A, d.Ã, -d.B*G, -1)
+#    X /= scale # this scale is always 1?
+#    d.X[:]  = X
+    d.X[:]  = sylvester(d.A, -d.Ã, d.B*G)
+    d.Xᵢ[:] = inv(d.X)
     d.K[:]  = G*d.Xᵢ
   end
 end
@@ -205,12 +207,13 @@ eval_g(d::Poleplacement, g, x) = nothing
 function eval_grad_f(d::Poleplacement, grad_f, x)
   common_first_sylvester!(d, x)
   X,Xᵢ,K,α = d.X,d.Xᵢ,d.K,d.α
-  # solve ÃU - UA = -S
+
   H = Xᵢ*K'
-  S = α*(-X.' + Xᵢ*Xᵢ.'*Xᵢ) + (1-α)*H*K  # Xi*Xi.'*Xi (X.'*X)\Xi
-  U,scale = LAPACK.trsyl!('N', 'N', d.Ã, d.A, -S, -1)
-  scale!(U, inv(scale)) # this scale is always 1?
+  S = α*(-transpose(X) + Xᵢ*transpose(Xᵢ)*Xᵢ) + (1-α)*H*K  # Xi*Xi.'*Xi (X.'*X)\Xi
+
+  # solve ÃU - UA = -S
+  U = sylvester(d.Ã, -d.A, S)
 
   # calculate gradient
-  grad_f[:] = vec((1-α)*H' + d.B.'*U.')
+  grad_f[:] = vec((1-α)*H' + transpose(d.B)*transpose(U))
 end
diff --git a/src/matrix_comps/covar.jl b/src/matrix_comps/covar.jl
index e27521a..35860ba 100644
--- a/src/matrix_comps/covar.jl
+++ b/src/matrix_comps/covar.jl
@@ -4,7 +4,7 @@
 Calculate the stationary covariance of an LTI model `sys`, driven by Gaussian
 white noise of covariance `W`
 """
-function covar{S}(sys::StateSpace{S,Val{:cont}}, W::StridedMatrix)
+function covar(sys::StateSpace{S,Val{:cont}}, W::StridedMatrix) where {S}
   A, B, C, D = sys.A, sys.B, sys.C, sys.D
   if size(B,2) != size(W, 1) || size(W, 1) != size(W, 2)
     error("W must be a square matrix the same size as `sys.B` columns")
@@ -16,7 +16,7 @@ function covar{S}(sys::StateSpace{S,Val{:cont}}, W::StridedMatrix)
     return C*Q*C'
   end
 end
-function covar{S}(sys::StateSpace{S,Val{:disc}}, W::StridedMatrix)
+function covar(sys::StateSpace{S,Val{:disc}}, W::StridedMatrix) where {S}
   A, B, C, D = sys.A, sys.B, sys.C, sys.D
   if size(B,2) != size(W, 1) || size(W, 1) != size(W, 2)
     error("W must be a square matrix the same size as `sys.B` columns")
diff --git a/src/matrix_comps/gram.jl b/src/matrix_comps/gram.jl
index d2dae2a..2593e1d 100644
--- a/src/matrix_comps/gram.jl
+++ b/src/matrix_comps/gram.jl
@@ -5,21 +5,21 @@ Compute the grammian of state-space system `sys`. If `opt` is `:c`, computes the
 controllability grammian. If `opt` is `:o`, computes the observability
 grammian.
 """
-function gram{S,T}(sys::StateSpace{S,Val{T}}, ::Type{Val{:c}})
+function gram(sys::StateSpace{S,Val{T}}, ::Type{Val{:c}}) where {S,T}
   if !isstable(sys)
     error("gram only valid for stable systems")
   else
     return lyap(sys.A, sys.B*sys.B',Val{T})
   end
 end
-function gram{S,T}(sys::StateSpace{S,Val{T}}, ::Type{Val{:o}})
+function gram(sys::StateSpace{S,Val{T}}, ::Type{Val{:o}}) where {S,T}
   if !isstable(sys)
     error("gram only valid for stable systems")
   else
     return lyap(sys.A', sys.C'*sys.C,Val{T})
   end
 end
-function gram{T}(sys::StateSpace, ::Type{Val{T}})
+function gram(sys::StateSpace, ::Type{Val{T}}) where {T}
   error("opt must be either :c for controllability grammian, or :o for observability grammian")
 end
 gram(sys::StateSpace, T::Symbol) = gram(sys,Val{T})
diff --git a/src/matrix_comps/lyapunov.jl b/src/matrix_comps/lyapunov.jl
index de22a02..fedb9ed 100644
--- a/src/matrix_comps/lyapunov.jl
+++ b/src/matrix_comps/lyapunov.jl
@@ -5,12 +5,12 @@ Compute the solution `X` to the discrete Lyapunov equation
 `AX + XA' + Q = 0`.
 """
 # TODO: Change code by SLICOT version
-function clyap{T<:BlasFloat}(A::StridedMatrix{T}, Q::StridedMatrix{T})
+function clyap(A::StridedMatrix{T}, Q::StridedMatrix{T}) where {T}
   lhs = kron(speye(size(A)...), A) + kron(conj(A),speye(size(A)...))
   x = -lhs\reshape(Q, prod(size(Q)), 1)
   return reshape(x, size(Q))
 end
-clyap{T1<:Real,T2<:Real}(A::StridedMatrix{T1}, Q::StridedMatrix{T2}) =
+clyap(A::StridedMatrix{T1}, Q::StridedMatrix{T2}) where {T1<:Real,T2<:Real} =
   clyap(float(A), float(Q))
 
 
@@ -21,17 +21,17 @@ Compute the solution `X` to the discrete Lyapunov equation
 `AXA' - X + Q = 0`.
 """
 # TODO: Change code by SLICOT version
-function dlyap{T<:BlasFloat}(A::StridedMatrix{T}, Q::StridedMatrix{T})
+function dlyap(A::StridedMatrix{T}, Q::StridedMatrix{T}) where {T}
   lhs = kron(conj(A), A)
   lhs = speye(size(lhs)...) - lhs
   x = lhs\reshape(Q, prod(size(Q)), 1)
   return reshape(x, size(Q))
 end
-dlyap{T1<:Real,T2<:Real}(A::StridedMatrix{T1}, Q::StridedMatrix{T2}) =
+dlyap(A::StridedMatrix{T1}, Q::StridedMatrix{T2}) where {T1<:Real,T2<:Real} =
   dlyap(float(A), float(Q))
 
-lyap{T<:BlasFloat}(A::StridedMatrix{T}, Q::StridedMatrix{T},::Type{Val{:cont}}) =
+lyap(A::StridedMatrix{T}, Q::StridedMatrix{T},::Type{Val{:cont}}) where {T} =
   clyap(A,Q)
 
-lyap{T<:BlasFloat}(A::StridedMatrix{T}, Q::StridedMatrix{T},::Type{Val{:disc}}) =
+lyap(A::StridedMatrix{T}, Q::StridedMatrix{T},::Type{Val{:disc}}) where {T} =
   dlyap(A,Q)
diff --git a/src/matrix_comps/norm.jl b/src/matrix_comps/norm.jl
index 3fa0678..cf10903 100644
--- a/src/matrix_comps/norm.jl
+++ b/src/matrix_comps/norm.jl
@@ -4,7 +4,7 @@
 Compute the `p`-norm of the system `sys`. `p` can be either `2` or `Inf`
 (default is 2)
 """
-function norm{S}(sys::StateSpace{S,Val{:cont}}, ::Type{Val{2}})
+function norm(sys::StateSpace{S,Val{:cont}}, ::Type{Val{2}}) where {S}
   A, B, C, D = sys.A, sys.B, sys.C, sys.D
   if !isstable(sys) || any(D .!= 0)
     return Inf
@@ -13,7 +13,7 @@ function norm{S}(sys::StateSpace{S,Val{:cont}}, ::Type{Val{2}})
     return sqrt(trace(C*Q*C'))
   end
 end
-function norm{S}(sys::StateSpace{S,Val{:disc}}, ::Type{Val{2}})
+function norm(sys::StateSpace{S,Val{:disc}}, ::Type{Val{2}}) where {S}
   A, B, C, D = sys.A, sys.B, sys.C, sys.D
   if !isstable(sys)
     return Inf
@@ -24,4 +24,4 @@ function norm{S}(sys::StateSpace{S,Val{:disc}}, ::Type{Val{2}})
 end
 norm(sys::LtiSystem) = norm(sys,Val{2})
 norm(sys::LtiSystem,n::Int) = norm(sys,Val{n})
-norm{T}(sys::LtiSystem,::Type{Val{T}}) = norm(ss(sys),Val{T})
+norm(sys::LtiSystem,::Type{Val{T}}) where {T} = norm(ss(sys),Val{T})
diff --git a/src/matrix_comps/realjordanform.jl b/src/matrix_comps/realjordanform.jl
index 233e1f1..1e056ae 100644
--- a/src/matrix_comps/realjordanform.jl
+++ b/src/matrix_comps/realjordanform.jl
@@ -17,7 +17,7 @@ julia> realjordanform(D)
 ```
 """
 
-function realjordanform{T<:Number}(D::AbstractVector{T})
+function realjordanform(D::AbstractVector{T}) where {T<:Number}
   sort!(D, by=imag)
   sort!(D, by=x->abs(imag(x))) # make sure conjugated pairs are next to eachother
   sort!(D, by=real)
@@ -27,7 +27,7 @@ function realjordanform{T<:Number}(D::AbstractVector{T})
   while i <= length(D)
     d = D[i]
     if isreal(d)
-      n = findlast(D, d) - i + 1 # multiplicity of real eigenvalue
+      n = findlast(x -> x==d, D) - i + 1 # multiplicity of real eigenvalue
       @assert all(D[i+j] == d for j = 1:n-1) "There should be $n eigenvalues equal to $d"
 
       # fill jordan block for real eigenvalue
@@ -38,7 +38,7 @@ function realjordanform{T<:Number}(D::AbstractVector{T})
       end
       i += n
     else
-      n = findlast(D, d) - i + 1 # multiplicity of complex eigenvalue
+      n = findlast(x -> x==d, D) - i + 1 # multiplicity of complex eigenvalue
       @assert all(D[i+j] == d for j = 1:n-1) "There should be $n eigenvalues equal to $d"
       @assert all(D[i+n+j] == conj(d) for j = 1:n-1) "There should be $n eigenvalues equal to $(conj(d))"
       # construct real block C
@@ -49,8 +49,8 @@ function realjordanform{T<:Number}(D::AbstractVector{T})
       # fill jordan block for complex eigenvalue
       J[i:i+1,i:i+1] = C
       for k = 1:n-1
-        J[i+2(k-1)+(0:1),i+2k+(0:1)] = eye(C)
-        J[i+2k+(0:1),i+2k+(0:1)]     = C
+        J[(0:1).+(i+2(k-1)), (0:1).+(i+2k)] = Diagonal{T}(I,size(C,1))
+        J[(0:1).+(i+2k), (0:1).+(i+2k)]     = C
       end
       i += 2n
     end
diff --git a/src/matrix_comps/riccati.jl b/src/matrix_comps/riccati.jl
index 159ae97..cc58b79 100644
--- a/src/matrix_comps/riccati.jl
+++ b/src/matrix_comps/riccati.jl
@@ -9,8 +9,8 @@ Laub, "A Schur Method for Solving Algebraic Riccati Equations."
 http://dspace.mit.edu/bitstream/handle/1721.1/1301/R-0859-05666488.pdf
 """
 # TO DO: Change code by SLICOT version
-function care{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T},
-            Q::StridedMatrix{T}, R::StridedMatrix{T})
+function care(A::StridedMatrix{T}, B::StridedMatrix{T},
+            Q::StridedMatrix{T}, R::StridedMatrix{T}) where {T}
     G = try
         B*inv(R)*B'
     catch
@@ -29,8 +29,9 @@ function care{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T},
     U21 = U[div(m,2)+1:m, 1:div(n,2)]
     return U21/U11
 end
-care{T1<:Real,T2<:Real,T3<:Real,T4<:Real}(A::StridedMatrix{T1}, B::StridedMatrix{T2},
-  Q::StridedMatrix{T3}, R::StridedMatrix{T4}) = care(float(A), float(B), float(Q), float(R))
+care(A::StridedMatrix{T1}, B::StridedMatrix{T2}, Q::StridedMatrix{T3},
+  R::StridedMatrix{T4}) where {T1<:Real,T2<:Real,T3<:Real,T4<:Real} =
+  care(float(A), float(B), float(Q), float(R))
 
 """
 `dare(A, B, Q, R)`
@@ -44,8 +45,8 @@ Laub, "A Schur Method for Solving Algebraic Riccati Equations."
 http://dspace.mit.edu/bitstream/handle/1721.1/1301/R-0859-05666488.pdf
 """
 # TO DO: Change code by SLICOT version
-function dare{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T},
-            Q::StridedMatrix{T}, R::StridedMatrix{T})
+function dare(A::StridedMatrix{T}, B::StridedMatrix{T}, Q::StridedMatrix{T},
+    R::StridedMatrix{T}) where {T}
     G = try
         B*inv(R)*B'
     catch
@@ -70,5 +71,6 @@ function dare{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T},
     U21 = U[div(m,2)+1:m, 1:div(n,2)]
     return U21/U11
 end
-dare{T1<:Real,T2<:Real,T3<:Real,T4<:Real}(A::StridedMatrix{T1}, B::StridedMatrix{T2},
-  Q::StridedMatrix{T3}, R::StridedMatrix{T4}) = dare(float(A), float(B), float(Q), float(R))
+dare(A::StridedMatrix{T1}, B::StridedMatrix{T2}, Q::StridedMatrix{T3},
+  R::StridedMatrix{T4}) where {T1<:Real,T2<:Real,T3<:Real,T4<:Real} =
+  dare(float(A), float(B), float(Q), float(R))
diff --git a/test/design/place.jl b/test/design/place.jl
index 227dee1..2dfb354 100644
--- a/test/design/place.jl
+++ b/test/design/place.jl
@@ -133,10 +133,10 @@ for (A,B,p,κ,c) in ((A₁,B₁,p₁,κ₁,c₁), (A₂,B₂,p₂,κ₂,c₂), (
                     (A₇,B₇,p₇,κ₇,c₇), (A₈,B₈,p₈,κ₈,c₈), (A₉,B₉,p₉,κ₉,c₉))
   for placer in placers
     F = placer(A,B,p)
-    λ, V = eig(A+B*F)
+    λ, V = eigen(A+B*F)
 
-    @test cond(V)     < κ
-    @test vecnorm(F)  < c
+    @test cond(V) < κ
+    @test norm(F) < c
     for i in 1:length(p)
       j = findfirst(y->isapprox(y, p[i], rtol=1e-3), λ)
       if j > 0
diff --git a/test/matrix_comps/realjordanform.jl b/test/matrix_comps/realjordanform.jl
index 0c1ad42..9791699 100644
--- a/test/matrix_comps/realjordanform.jl
+++ b/test/matrix_comps/realjordanform.jl
@@ -6,6 +6,6 @@ JD = zeros(Int, 7,7)
 JD[1,1] = -1
 JD[2:3,2:3] = C1
 JD[4:5,4:5] = JD[6:7,6:7] = C2
-JD[4:5,6:7] = eye(Int, 2)
+JD[4:5,6:7] = Diagonal{Int}(I,2)
 
 @test realjordanform(D) == JD
diff --git a/test/runtests.jl b/test/runtests.jl
index 02f5c3e..eb7ba1c 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -1,6 +1,7 @@
 using ControlToolbox
 using NLopt
-using Base.Test
+using Test
+using LinearAlgebra
 
 # write your own tests here
 include("matrix_comps/realjordanform.jl")