• Adds support for Julia 0.6

• Drops support for Julia 0.4

REQUIRE

@@ -1,2 +1,2 @@
-julia 0.4
-StatsBase 0.8.0
+julia 0.5
+StatsBase 0.8.0

src/ToeplitzMatrices.jl

@@ -1,8 +1,8 @@
 __precompile__(true)
 
 module ToeplitzMatrices
+    using Compat
 
-import Compat.view
 
 import StatsBase
 include("iterativeLinearSolvers.jl")
@@ -16,7 +16,7 @@ export Toeplitz, SymmetricToeplitz, Circulant, TriangularToeplitz, Hankel,
        chan, strang
 
 # Abstract
-abstract AbstractToeplitz{T<:Number} <: AbstractMatrix{T}
+@compat abstract type AbstractToeplitz{T<:Number} <: AbstractMatrix{T} end
 
 size(A::AbstractToeplitz) = (size(A, 1), size(A, 2))
 getindex(A::AbstractToeplitz, i::Integer) = A[mod(i, size(A,1)), div(i, size(A,1)) + 1]
@@ -30,7 +30,7 @@ convert{T}(::Type{AbstractArray{T}}, S::AbstractToeplitz) = convert(AbstractToep
 # Convert an abstract Toeplitz matrix to a full matrix
 function full{T}(A::AbstractToeplitz{T})
     m, n = size(A)
-    Af = Array(T, m, n)
+    Af = Matrix{T}(m, n)
     for j = 1:n
         for i = 1:m
             Af[i,j] = A[i,j]
@@ -142,7 +142,7 @@ function Toeplitz(vc::Vector, vr::Vector)
     T = promote_type(eltype(vc), eltype(vr), Float32)
     vcp, vrp = Vector{T}(vc), Vector{T}(vr)
 
-    tmp = Array(promote_type(T, Complex{Float32}), m + n - 1)
+    tmp = Vector{promote_type(T, Complex{Float32})}(m + n - 1)
     copy!(tmp, vcp)
     for i = 1:n - 1
         tmp[i + m] = vrp[n - i + 1]
@@ -327,7 +327,7 @@ end
 
 function strang{T}(A::AbstractMatrix{T})
     n = size(A, 1)
-    v = Array(T, n)
+    v = Vector{T}(n)
     n2 = div(n, 2)
     for i = 1:n
         if i <= n2 + 1
@@ -340,7 +340,7 @@ function strang{T}(A::AbstractMatrix{T})
 end
 function chan{T}(A::AbstractMatrix{T})
     n = size(A, 1)
-    v = Array(T, n)
+    v = Vector{T}(n)
     for i = 1:n
         v[i] = ((n - i + 1) * A[i, 1] + (i - 1) * A[1, min(n - i + 2, n)]) / n
     end
@@ -484,7 +484,7 @@ StatsBase.levinson(A::AbstractToeplitz, B::StridedVecOrMat) =
 #     n, p, _ = size(Mc)
 #     tmp = zeros(Complex{T}, 2n)
 #     dft = plan_fft!(tmp)
-#     Mc_dft = Array(Complex{T}, 2n, p, p)
+#     Mc_dft = Array{Complex{T}}(2n, p, p)
 #     for j = 1:p
 #         for i = 1:p
 #             Mc_dft[1,i,j] = complex(Mc[1,i,j])
@@ -545,7 +545,7 @@ size(H::Hankel,k...) = size(H.T,k...)
 # Full version of a Hankel matrix
 function full{T}(A::Hankel{T})
     m, n = size(A)
-    Af = Array(T, m, n)
+    Af = Matrix{T}(m, n)
     for j = 1:n
         for i = 1:m
             Af[i,j] = A[i,j]

src/iterativeLinearSolvers.jl

@@ -1,9 +1,10 @@
 module IterativeLinearSolvers
+    using Compat
 
 # Included from https://github.com/andreasnoack/IterativeLinearSolvers.jl
 # Eventually, use IterativeSolvers.jl
 
-typealias Preconditioner{T} Union{AbstractMatrix{T}, Factorization{T}}
+@compat Preconditioner{T} = Union{AbstractMatrix{T}, Factorization{T}}
 
 function cg{T<:LinAlg.BlasReal}(A::AbstractMatrix{T},
     x::AbstractVector{T},
@@ -209,4 +210,4 @@ function cgs{T<:Number}(A::AbstractMatrix{T},
     return x, error, iter, flag
 end
 
-end
+end

test/runtests.jl

@@ -33,110 +33,110 @@ for (As, Al, st) in ((Toeplitz(0.9.^(0:ns-1), 0.4.^(0:ns-1)),
                         TriangularToeplitz(complex(0.9.^(0:nl - 1)), :L),
                             "Complex lower triangular"))
     print("$st: ")
-    @test_approx_eq As * xs full(As) * xs
-    @test_approx_eq Al * xl full(Al) * xl
-    @test_approx_eq A_ldiv_B!(As, LinAlg.copy_oftype(xs, eltype(As))) full(As) \ xs
-    @test_approx_eq A_ldiv_B!(Al, LinAlg.copy_oftype(xl, eltype(Al))) full(Al) \ xl
+    @test As * xs ≈ full(As) * xs
+    @test Al * xl ≈ full(Al) * xl
+    @test A_ldiv_B!(As, LinAlg.copy_oftype(xs, eltype(As))) ≈ full(As) \ xs
+    @test A_ldiv_B!(Al, LinAlg.copy_oftype(xl, eltype(Al))) ≈ full(Al) \ xl
     println("OK!")
 end
 
 print("Real general rectangular: ")
 Ar1 = Toeplitz(0.9.^(0:nl-1), 0.4.^(0:ns-1))
 Ar2 = Toeplitz(0.9.^(0:ns-1), 0.4.^(0:nl-1))
-@test_approx_eq Ar1 * xs full(Ar1) * xs
-@test_approx_eq Ar2 * xl full(Ar2) * xl
+@test Ar1 * xs ≈ full(Ar1) * xs
+@test Ar2 * xl ≈ full(Ar2) * xl
 println("OK!")
 
 print("Complex general rectangular: ")
 Ar1 = Toeplitz(complex(0.9.^(0:nl-1)), complex(0.4.^(0:ns-1)))
 Ar2 = Toeplitz(complex(0.9.^(0:ns-1)), complex(0.4.^(0:nl-1)))
-@test_approx_eq Ar1 * xs full(Ar1) * xs
-@test_approx_eq Ar2 * xl full(Ar2) * xl
+@test Ar1 * xs ≈ full(Ar1) * xs
+@test Ar2 * xl ≈ full(Ar2) * xl
 println("OK!")
 
 print("Symmetric Toeplitz: ")
 As = SymmetricToeplitz(0.9.^(0:ns-1))
-Ab = SymmetricToeplitz(abs(randn(ns)))
+Ab = SymmetricToeplitz(abs.(randn(ns)))
 Al = SymmetricToeplitz(0.9.^(0:nl-1))
-@test_approx_eq As * xs full(As) * xs
-@test_approx_eq Ab * xs full(Ab) * xs
-@test_approx_eq Al * xl full(Al) * xl
-@test_approx_eq A_ldiv_B!(As, copy(xs)) full(As) \ xs
-@test_approx_eq A_ldiv_B!(Ab, copy(xs)) full(Ab) \ xs
-@test_approx_eq A_ldiv_B!(Al, copy(xl)) full(Al) \ xl
-@test_approx_eq StatsBase.levinson(As, xs) full(As) \ xs
-@test_approx_eq StatsBase.levinson(Ab, xs) full(Ab) \ xs
-@test_approx_eq StatsBase.levinson(Al, xl) full(Al) \ xl
+@test As * xs ≈ full(As) * xs
+@test Ab * xs ≈ full(Ab) * xs
+@test Al * xl ≈ full(Al) * xl
+@test A_ldiv_B!(As, copy(xs)) ≈ full(As) \ xs
+@test A_ldiv_B!(Ab, copy(xs)) ≈ full(Ab) \ xs
+@test A_ldiv_B!(Al, copy(xl)) ≈ full(Al) \ xl
+@test StatsBase.levinson(As, xs) ≈ full(As) \ xs
+@test StatsBase.levinson(Ab, xs) ≈ full(Ab) \ xs
+@test StatsBase.levinson(Al, xl) ≈ full(Al) \ xl
 println("OK!")
 
 println("\nHankel")
 print("Real square: ")
 H = Hankel([1.0,2,3,4,5],[5.0,6,7,8,0])
 x = ones(5)
-@test_approx_eq full(H)*x H*x
+@test full(H)*x ≈ H*x
 
 Hs = Hankel(0.9.^(ns-1:-1:0), 0.4.^(0:ns-1))
 Hl = Hankel(0.9.^(nl-1:-1:0), 0.4.^(0:nl-1))
-@test_approx_eq Hs * xs[:,1] full(Hs) * xs[:,1]
-@test_approx_eq Hs * xs full(Hs) * xs
-@test_approx_eq Hl * xl full(Hl) * xl
+@test Hs * xs[:,1] ≈ full(Hs) * xs[:,1]
+@test Hs * xs ≈ full(Hs) * xs
+@test Hl * xl ≈ full(Hl) * xl
 println("OK!")
 
 print("Complex square: ")
 H = Hankel(complex([1.0,2,3,4,5]), complex([5.0,6,7,8,0]))
 x = ones(5)
-@test_approx_eq full(H)*x H*x
+@test full(H)*x ≈ H*x
 
 Hs = Hankel(complex(0.9.^(ns-1:-1:0)), complex(0.4.^(0:ns-1)))
 Hl = Hankel(complex(0.9.^(nl-1:-1:0)), complex(0.4.^(0:nl-1)))
-@test_approx_eq Hs * xs[:,1] full(Hs) * xs[:,1]
-@test_approx_eq Hs * xs full(Hs) * xs
-@test_approx_eq Hl * xl full(Hl) * xl
+@test Hs * xs[:,1] ≈ full(Hs) * xs[:,1]
+@test Hs * xs ≈ full(Hs) * xs
+@test Hl * xl ≈ full(Hl) * xl
 println("OK!")
 
 print("Real rectangular: ")
 Hs = Hankel(0.9.^(ns-1:-1:0), 0.4.^(0:nl-1))
 Hl = Hankel(0.9.^(nl-1:-1:0), 0.4.^(0:ns-1))
-@test_approx_eq Hs * xl[:,1] full(Hs) * xl[:,1]
-@test_approx_eq Hs * xl full(Hs) * xl
-@test_approx_eq Hl * xs full(Hl) * xs
+@test Hs * xl[:,1] ≈ full(Hs) * xl[:,1]
+@test Hs * xl ≈ full(Hs) * xl
+@test Hl * xs ≈ full(Hl) * xs
 println("OK!")
 
 print("Complex rectangular: ")
 Hs = Hankel(complex(0.9.^(ns-1:-1:0)), complex(0.4.^(0:nl-1)))
 Hl = Hankel(complex(0.9.^(nl-1:-1:0)), complex(0.4.^(0:ns-1)))
-@test_approx_eq Hs * xl[:,1] full(Hs) * xl[:,1]
-@test_approx_eq Hs * xl full(Hs) * xl
-@test_approx_eq Hl * xs full(Hl) * xs
+@test Hs * xl[:,1] ≈ full(Hs) * xl[:,1]
+@test Hs * xl ≈ full(Hs) * xl
+@test Hl * xs ≈ full(Hl) * xs
 println("OK!")
 
 
 if isdir(Pkg.dir("FastTransforms"))
     print("\nBigFloat")
     using FastTransforms
     T = Toeplitz(BigFloat[1,2,3,4,5], BigFloat[1,6,7,8,0])
-    @test_approx_eq T*ones(BigFloat,5) [22,24,19,16,15]
+    @test T*ones(BigFloat,5) ≈ [22,24,19,16,15]
 
     n = 512
     r = map(BigFloat,rand(n))
     T = Toeplitz(r,[r[1];map(BigFloat,rand(n-1))])
-    @test_approx_eq T*ones(BigFloat,n) full(T)*ones(BigFloat,n)
+    @test T*ones(BigFloat,n) ≈ full(T)*ones(BigFloat,n)
 
     T = TriangularToeplitz(BigFloat[1,2,3,4,5],:L)
-    @test_approx_eq T*ones(BigFloat,5) full(T)*ones(BigFloat,5)
+    @test T*ones(BigFloat,5) ≈ full(T)*ones(BigFloat,5)
 
     n = 512
     r = map(BigFloat,rand(n))
     T = TriangularToeplitz(r,:L)
-    @test_approx_eq T*ones(BigFloat,n) full(T)*ones(BigFloat,n)
+    @test T*ones(BigFloat,n) ≈ full(T)*ones(BigFloat,n)
 
     T = TriangularToeplitz(BigFloat[1,2,3,4,5],:U)
-    @test_approx_eq T*ones(BigFloat,5) full(T)*ones(BigFloat,5)
+    @test T*ones(BigFloat,5) ≈ full(T)*ones(BigFloat,5)
 
     n = 512
     r = map(BigFloat,rand(n))
     T = TriangularToeplitz(r,:U)
-    @test_approx_eq T*ones(BigFloat,n) full(T)*ones(BigFloat,n)
+    @test T*ones(BigFloat,n) ≈ full(T)*ones(BigFloat,n)
     println("OK!")
 end