Drop 0.5 support, tests pass in 0.6 with no deprecation

Author: Sheehan Olver

.travis.yml

@@ -7,7 +7,6 @@ addons:
 os:
     - linux
 julia:
-    - 0.5
     - 0.6
     - nightly
 matrix:

REQUIRE

@@ -1,6 +1,5 @@
-julia 0.5
+julia 0.6
 Combinatorics 0.2
 Distributions 0.8.10
-OrdinaryDiffEq
+OrdinaryDiffEq 2.19.1
 GSL 0.3.1
-Compat 0.9.2

src/FormalPowerSeries.jl

@@ -17,10 +17,10 @@ export FormalPowerSeries, fps, tovector, trim, isunit, isnonunit,
 #############################
 
 # Definition [H, p.9] - we limit this to finitely many coefficients
-type FormalPowerSeries{Coefficients}
+mutable struct FormalPowerSeries{Coefficients}
   c :: Dict{BigInt, Coefficients}
-  FormalPowerSeries{Coefficients}(c::Dict{BigInt, Coefficients}) = new(c)
-  function FormalPowerSeries{Coefficients}(v::Vector{Coefficients})
+  FormalPowerSeries{Coefficients}(c::Dict{BigInt, Coefficients}) where Coefficients = new(c)
+  function FormalPowerSeries{Coefficients}(v::Vector{Coefficients}) where Coefficients
     c=Dict{BigInt, Coefficients}()
     for i in eachindex(v)
       if v[i] != 0
@@ -30,6 +30,9 @@ type FormalPowerSeries{Coefficients}
     FormalPowerSeries{Coefficients}(c)
   end
 end
+
+FormalPowerSeries(v::Vector{T}) where T = FormalPowerSeries{T}(v)
+
 #Convenient abbreviation for floats
 fps = FormalPowerSeries{Float64}
 
@@ -138,7 +141,8 @@ function CauchyProduct{T}(P::FormalPowerSeries{T}, Q::FormalPowerSeries{T})
 end
 
 #Hadamard product [H, p.10] - the elementwise product
-.*{T}(P::FormalPowerSeries{T}, Q::FormalPowerSeries{T}) = HadamardProduct(P, Q)
+broadcast(::typeof(*), P::FormalPowerSeries{T}, Q::FormalPowerSeries{T}) where T =
+  HadamardProduct(P, Q)
 function HadamardProduct{T}(P::FormalPowerSeries{T}, Q::FormalPowerSeries{T})
   c = Dict{BigInt, T}()
   for (k,v) in P.c
@@ -193,7 +197,7 @@ end
 #TODO implement the FFT-based algorithm of one of the following
 #  doi:10.1109/TAC.1984.1103499
 #  https://cs.uwaterloo.ca/~glabahn/Papers/tamir-george-1.pdf
-function reciprocal{T}(P::FormalPowerSeries{T}, n::Integer)
+function reciprocal(P::FormalPowerSeries, n::Integer)
   n<0 && error(sprintf("Invalid inverse truncation length %d requested", n))
 
   a = tovector(P, 0:n-1) #Extract original coefficients in vector
@@ -205,11 +209,11 @@ function reciprocal{T}(P::FormalPowerSeries{T}, n::Integer)
   for k=2:n
     b[k] = -inv_a1 * sum([b[k+1-i] * a[i] for i=2:k])
   end
-  FormalPowerSeries{T}(b)
+  FormalPowerSeries(b)
 end
 
 #Derivative of fps [H. Sec.1.4, p.18]
-function derivative{T}(P::FormalPowerSeries{T})
+function derivative(P::FormalPowerSeries{T}) where T
     c = Dict{BigInt, T}()
     for (k,v) in P.c
         if k != 0 && v != 0
@@ -220,7 +224,7 @@ function derivative{T}(P::FormalPowerSeries{T})
 end
 
 #[H, Sec.1.4, p.18]
-function isconstant{T}(P::FormalPowerSeries{T})
+function isconstant(P::FormalPowerSeries)
   for (k,v) in P.c
     if k!=0 && v!=0
       return false
@@ -232,7 +236,7 @@ end
 
 
 # Power of fps [H, Sec.1.5, p.35]
-function ^{T}(P::FormalPowerSeries{T}, n :: Integer)
+function ^(P::FormalPowerSeries{T}, n::Integer) where T
     if n == 0
         return FormalPowerSeries{T}([one(T)])
     elseif n > 1
@@ -293,10 +297,10 @@ inv(P::FormalPowerSeries, n::Integer) = reversion(P, n)
 # [H., Sec. 1.8, p. 51]       #
 ###############################
 
-type FormalLaurentSeries{Coefficients}
+mutable struct FormalLaurentSeries{Coefficients}
   c :: Dict{BigInt, Coefficients}
-  FormalLaurentSeries{Coefficients}(c::Dict{BigInt, Coefficients}) = new(c)
-  function FormalLaurentSeries{Coefficients}(v::Vector{Coefficients})
+  FormalLaurentSeries{Coefficients}(c::Dict{BigInt, Coefficients}) where Coefficients = new(c)
+  function FormalLaurentSeries{Coefficients}(v::Vector{Coefficients}) where Coefficients
     c = new(c)
     for i=1:length(v)
       c[i] = v[i]

src/GaussianEnsembles.jl

@@ -32,20 +32,20 @@ Example of usage:
 
     β = 2 #β = 1, 2, 4 generates real, complex and quaternionic matrices respectively.
     d = Wigner{β} #same as GaussianHermite{β}
-    
+
     n = 20 #Generate square matrices of this size
 
     S = rand(d, n)       #Generate a 20x20 symmetric Wigner matrix
     T = tridrand(d, n)   #Generate the symmetric tridiagonal form
     v = eigvalrand(d, n) #Generate a sample of eigenvalues
 """
-immutable GaussianHermite{β} <: ContinuousMatrixDistribution end
+struct GaussianHermite{β} <: ContinuousMatrixDistribution end
 GaussianHermite(β) = GaussianHermite{β}()
 
 """
 Synonym for GaussianHermite{β}
 """
-typealias Wigner{β} GaussianHermite{β}
+const Wigner{β} = GaussianHermite{β}
 
 rand{β}(d::Type{Wigner{β}}, dims...) = rand(d(), dims...)
 
@@ -70,7 +70,7 @@ function rand(d::Wigner{4}, n::Int)
     return Hermitian((A + A') / normalization)
 end
 
-rand{β}(d::Wigner{β}, n::Int) = 
+rand{β}(d::Wigner{β}, n::Int) =
     throw(ValueError("Cannot sample random matrix of size $n x $n for β=$β"))
 
 function rand{β}(d::Wigner{β}, dims...)
@@ -85,7 +85,7 @@ end
 Generates a nxn symmetric tridiagonal Wigner matrix
 
 Unlike for `rand(Wigner{β}, n)`, which is restricted to β=1,2 or 4,
-`trirand(Wigner{β}, n)` will generate a 
+`trirand(Wigner{β}, n)` will generate a
 
 The β=∞ case is defined in Edelman, Persson and Sutton, 2012
 """
@@ -143,13 +143,13 @@ end
 # Laguerre ensemble #
 #####################
 
-type GaussianLaguerre <: ContinuousMatrixDistribution
+mutable struct GaussianLaguerre <: ContinuousMatrixDistribution
   beta::Real
   a::Real
 end
-typealias Wishart GaussianLaguerre
+const Wishart = GaussianLaguerre
+
 
- 
 #Generates a NxN Hermitian Wishart matrix
 #TODO Check - the eigenvalue distribution looks funky
 #TODO The appropriate matrix size should be calculated from a and one matrix dimension
@@ -215,13 +215,13 @@ end
 # Jacobi ensemble #
 ###################
 
-#Generates a NxN self-dual MANOVA matrix 
-type GaussianJacobi <: ContinuousMatrixDistribution
+#Generates a NxN self-dual MANOVA matrix
+mutable struct GaussianJacobi <: ContinuousMatrixDistribution
   beta::Real
   a::Real
   b::Real
 end
-typealias MANOVA  GaussianJacobi
+const MANOVA = GaussianJacobi
 
 function rand(d::GaussianJacobi, m::Integer)
   w1 = Wishart(m, int(2.0*d.a/d.beta), d.beta)
@@ -267,7 +267,7 @@ function sprand(d::GaussianJacobi, n::Integer, a::Real, b::Real)
   for i=1:n
     CoordI[i], CoordJ[i] = i, i
     Values[i] = i==1 ? c[n] : c[n+1-i] * sp[n+1-i]
-  end    
+  end
   for i=1:n
     CoordI[n+i], CoordJ[n+i] = i, n+i
     Values[n+i] = i==n ? s[1] : s[n+1-i] * sp[n-i]
@@ -297,7 +297,7 @@ function sprand(d::GaussianJacobi, n::Integer, a::Real, b::Real)
     CoordI[7n-3+i], CoordJ[7n-3+i] = n+i,i+1
     Values[7n-3+i] = -s[n-i]*cp[n-i]
   end
-  
+
   return sparse(CoordI, CoordJ, Values)
 end
 
@@ -307,7 +307,7 @@ function eigvalrand(d::GaussianJacobi, n::Integer)
   c, s, cp, sp = SampleCSValues(n, d.a, d.b, d.beta)
   dv = [i==1 ? c[n] : c[n+1-i] * sp[n+1-i] for i=1:n]
   ev = [-s[n+1-i]*cp[n-i] for i=1:n-1]
-  
+
   ##TODO: understand why dv and ev are returned as Array{Any,1}
   M = Bidiagonal(convert(Array{Float64,1},dv), convert(Array{Float64,1},ev), false)
   return svdvals(M)
@@ -339,4 +339,3 @@ function eigvaljpdf{Eigenvalue<:Number}(d::GaussianJacobi, lambda::Vector{Eigenv
 
   return c * VandermondeDeterminant(lambda, beta) * Prod * exp(-Energy)
 end
-

src/Ginibre.jl

@@ -5,7 +5,7 @@ import Base.rand
 #This ensemble lives in GL(N, F), the set of all invertible N x N matrices
 #over the field F
 #For beta=1,2,4, F=R, C, H respectively
-immutable Ginibre <: ContinuousMatrixDistribution
+struct Ginibre <: ContinuousMatrixDistribution
    beta::Float64
    N::Integer
 end
@@ -32,7 +32,7 @@ function jpdf{z<:Complex}(Z::AbstractMatrix{z})
 end
 
 #Dyson Circular orthogonal, unitary and symplectic ensembles
-immutable CircularOrthogonal
+struct CircularOrthogonal
     N :: Int64
 end
 
@@ -41,13 +41,13 @@ function rand(M::CircularOrthogonal)
     U * U'
 end
 
-immutable CircularUnitary
+struct CircularUnitary
     N :: Int64
 end
 
 rand(M::CircularUnitary) = rand(Ginibre(2, M.N))
 
-immutable CircularSymplectic
+struct CircularSymplectic
     N :: Int64
 end
 

src/Haar.jl

@@ -2,7 +2,7 @@ export permutations_in_Sn, compose, cycle_structure, data, part, #Functions work
     partition, Haar, expectation, WeingartenUnitary
 
 
-typealias partition Vector{Int}
+const partition = Vector{Int}
 #Functions working with partitions and permutations
 # TODO Migrate these functions to Catalan
 
@@ -24,7 +24,7 @@ end
 
 function permutations_in_Sn(n::Integer)
     P = permutation_calloc(n)
-    while true 
+    while true
         produce(P)
         try permutation_next(P) catch break end
     end
@@ -65,7 +65,7 @@ data(P::Ptr{gsl_permutation}) = [convert(Int64, x)+1 for x in
     pointer_to_array(permutation_data(P), (convert(Int64, permutation_size(P)) ,))]
 
 
-type Haar <: ContinuousMatrixDistribution
+mutable struct Haar <: ContinuousMatrixDistribution
     beta::Real
 end
 
@@ -88,10 +88,10 @@ function expectation(X::Expr)
     if X.head != :call
         error(string("Unexpected type of expression: ", X.head))
     end
-    
+
     n = length(X.args) - 1
     if n < 1 return eval(X) end #nothing to do Haar-wise
-    
+
     if X.args[1] != :*
         error("Unexpected expression, only products supported")
     end
@@ -144,7 +144,7 @@ function expectation(X::Expr)
             sigma_inv=permutation_inverse(sigma)
             #Compose the permutations
             perm=compose(sigma_inv, tau)
-            
+
             #Compute cycle structure, i.e. lengths of each cycle in the cycle
             #factorization of the permutatation
             cyclestruct = cycle_structure(perm)
@@ -245,7 +245,7 @@ function expectation(X::Expr)
                 ExprBlob, start_idx, end_idx = ExprChunk
                 print(ExprChunk, " => ")
                 if start_idx == end_idx #Have a cycle; this is a trace
-                    ex= length(ExprBlob)==1 ? :(trace($(ExprBlob[1]))) : 
+                    ex= length(ExprBlob)==1 ? :(trace($(ExprBlob[1]))) :
                         Expr(:call, :trace, Expr(:call, :*, ExprBlob...))
                 else #Not a cycle, regular chain of multiplications
                     ex= length(ExprBlob)==1 ? ExprBlob[1] :
@@ -288,4 +288,3 @@ function WeingartenUnitary(P::partition)
     end
     thesum
 end
-

src/InvariantEnsembles.jl

@@ -71,20 +71,20 @@ end
 
 ## Ensembles
 
-type InvariantEnsemble{D}
+mutable struct InvariantEnsemble{D}
     basis::Array{Float64,2}         # the m x n array of the first n weighted OPs evaluated at m Chebyshev points
     domain::D                       # the sub domain  of the real line
-    InvariantEnsemble(b,d) = new(b,d)
+    InvariantEnsemble{D}(b,d) where D = new(b,d)
 end
 
 InvariantEnsemble(basis::Matrix,d::Domain) =
     InvariantEnsemble{typeof(d)}(basis,d)
 
 InvariantEnsemble(basis::Matrix,d::Vector) =
-    InvariantEnsemble(basis,Interval(d[1],d[2]))
+    InvariantEnsemble(basis,Segment(d[1],d[2]))
 
 InvariantEnsemble(basis,d::Vector) =
-    InvariantEnsemble(basis,Interval(d[1],d[2]))
+    InvariantEnsemble(basis,Segment(d[1],d[2]))
 
 
 ## n, where the invariant ensemble is n x n
@@ -123,7 +123,7 @@ end
 function adaptiveie(w,μ0,α,β,d)
   for logn = 4:20
     m=2^logn + 1
-    pts=points(Interval(d[1],d[2]),m)
+    pts=points(Segment(d[1],d[2]),m)
     pv=orthonormalpolynomialsvalues(μ0,α,β,pts)
 
     wv=w(pts)
@@ -135,7 +135,7 @@ function adaptiveie(w,μ0,α,β,d)
 
         m=length(chop!(cfs,200*eps()))
 
-        pts=points(Interval(d[1],d[2]),m)
+        pts=points(Segment(d[1],d[2]),m)
         pv=orthonormalpolynomialsvalues(μ0,α,β,pts)
         wv=w(pts)
 

src/RandomMatrices.jl

@@ -1,7 +1,6 @@
 module RandomMatrices
 
 using Combinatorics
-using Compat
 using GSL
 using OrdinaryDiffEq
 using DiffEqBase # This line is only needed on v0.5, and comes free from OrdinaryDiffEq on v0.6
@@ -20,7 +19,7 @@ export bidrand,    #Generate random bidiagonal matrix
        cumulant, freecumulant, cf, mgf,
        cdf, pdf, entropy, insupport, mean, median, modes, kurtosis, skewness, std, var, moment
 
-typealias Dim2 Tuple{Int, Int} #Dimensions of a rectangular matrix
+const Dim2 = Tuple{Int, Int} #Dimensions of a rectangular matrix
 
 #Classical Gaussian matrix ensembles
 include("GaussianEnsembles.jl")

src/StochasticProcess.jl

@@ -3,17 +3,17 @@
 import Base: start, next, done
 export AiryProcess, BrownianProcess, WhiteNoiseProcess, next!
 
-abstract StochasticProcess{T<:Real}
+abstract type StochasticProcess{T<:Real} end
 
-immutable WhiteNoiseProcess{T<:Real} <: StochasticProcess{T}
+struct WhiteNoiseProcess{T<:Real} <: StochasticProcess{T}
     dt::T
 end
 
-immutable BrownianProcess{T<:Real} <: StochasticProcess{T}
+struct BrownianProcess{T<:Real} <: StochasticProcess{T}
     dt::T
 end
 
-immutable AiryProcess{S<:Real, T<:Real} <: StochasticProcess{T}
+struct AiryProcess{S<:Real, T<:Real} <: StochasticProcess{T}
     dt::T
     beta::S
 end
@@ -67,5 +67,3 @@ function next{T}(p::AiryProcess{T}, S::SymTridiagonal{T})
 
     (eigmax(S), S)
 end
-
-