Fix deprecations (#39)

* Fix deprecations

* BUG: clean up test that should have been changed in last PR

Author: femtocleaner[bot]

src/BasisMatrices.jl

@@ -42,25 +42,21 @@ export nodes, get_coefs, funfitxy, funfitf, funeval, evalbase,
 #re-exports
 export gridmake, gridmake!, ckron
 
-@compat abstract type BasisFamily end
-@compat abstract type BasisParams end
+abstract type BasisFamily end
+abstract type BasisParams end
 const IntSorV = Union{Int, AbstractVector{Int}}
-@static if VERSION >= v"0.6.0-dev.2123"
-    const TensorX = Union{Tuple{Vararg{AbstractVector}},AbstractVector{<:AbstractVector}}
-else
-    const TensorX = Union{Tuple{Vararg{AbstractVector}},AbstractVector{TypeVar(:TV,AbstractVector)}}
-end
+const TensorX = Union{Tuple{Vararg{AbstractVector}},AbstractVector{<:AbstractVector}}
 
 include("util.jl")
 include("spline_sparse.jl")
 
 # include the families
 
 # BasisParams interface
-Base.issparse{T<:BasisParams}(::Type{T}) = false
+Base.issparse(::Type{T}) where {T<:BasisParams} = false
 Base.ndims(::BasisParams) = 1
 for f in [:family, :family_name, :(Base.issparse), :(Base.eltype)]
-    @eval $(f){T<:BasisParams}(::T) = $(f)(T)
+    @eval $(f)(::T) where {T<:BasisParams} = $(f)(T)
 end
 include("cheb.jl")
 include("lin.jl")
@@ -72,8 +68,8 @@ evalbase(p::BasisParams, x::Number, args...) = evalbase(p, [x], args...)
 
 # now some more interface methods that only make sense once we have defined
 # the subtypes
-basis_eltype{TP<:BasisParams}(::TP, x) = promote_type(eltype(TP), eltype(x))
-basis_eltype{TP<:BasisParams}(::Type{TP}, x) = promote_type(eltype(TP), eltype(x))
+basis_eltype(::TP, x) where {TP<:BasisParams} = promote_type(eltype(TP), eltype(x))
+basis_eltype(::Type{TP}, x) where {TP<:BasisParams} = promote_type(eltype(TP), eltype(x))
 """
     basis_eltype(p::Union{BasisParams,Type{<:BasisParams}, x)
 
@@ -88,31 +84,31 @@ basis_eltype
 # the default is just a dense matrix
 # because there is only one dense version, we will start with the sparse
 # case and overload for Cheb
-bmat_type{TP<:BasisParams}(::Type{TP}, x) = SparseMatrixCSC{basis_eltype(TP, x),Int}
-bmat_type{TP<:BasisParams,T2}(::Type{T2}, ::Type{TP}, x) = bmat_type(TP, x)
-function bmat_type{TP<:BasisParams,T2<:SplineSparse}(::Type{T2}, ::Type{TP}, x)
+bmat_type(::Type{TP}, x) where {TP<:BasisParams} = SparseMatrixCSC{basis_eltype(TP, x),Int}
+bmat_type(::Type{T2}, ::Type{TP}, x) where {TP<:BasisParams,T2} = bmat_type(TP, x)
+function bmat_type(::Type{T2}, ::Type{TP}, x) where {TP<:BasisParams,T2<:SplineSparse}
     SplineSparse{basis_eltype(TP, x),Int}
 end
 
-bmat_type{T<:ChebParams}(::Type{T}, x) = Matrix{basis_eltype(T, x)}
-function bmat_type{TP<:ChebParams,T2<:SplineSparse}(::Type{T2}, ::Type{TP}, x)
+bmat_type(::Type{T}, x) where {T<:ChebParams} = Matrix{basis_eltype(T, x)}
+function bmat_type(::Type{T2}, ::Type{TP}, x) where {TP<:ChebParams,T2<:SplineSparse}
     bmat_type(TP, x)
 end
 
 # version where there isn't an x passed
-bmat_type{TP<:BasisParams}(::Type{TP}) = bmat_type(TP, one(eltype(TP)))
-function bmat_type{TP<:BasisParams,T2}(::Type{T2}, ::Type{TP})
+bmat_type(::Type{TP}) where {TP<:BasisParams} = bmat_type(TP, one(eltype(TP)))
+function bmat_type(::Type{T2}, ::Type{TP}) where {TP<:BasisParams,T2}
     bmat_type(T2, TP, one(eltype(TP)))
 end
 
 # add methods to instances
-bmat_type{T<:BasisParams}(::T) = bmat_type(T)
-bmat_type{TF<:BasisParams,T2}(ss::Type{T2}, ::TF) = bmat_type(T2, TF)
-bmat_type{TF<:BasisParams,T2}(ss::Type{T2}, ::TF, x) = bmat_type(T2, TF, x)
+bmat_type(::T) where {T<:BasisParams} = bmat_type(T)
+bmat_type(ss::Type{T2}, ::TF) where {TF<:BasisParams,T2} = bmat_type(T2, TF)
+bmat_type(ss::Type{T2}, ::TF, x) where {TF<:BasisParams,T2} = bmat_type(T2, TF, x)
 
 # default method for evalbase with extra type hint is to just ignore the extra
 # type hint
-evalbase{T}(::Type{T}, bp::BasisParams, x, order) = evalbase(bp, x, order)
+evalbase(::Type{T}, bp::BasisParams, x, order) where {T} = evalbase(bp, x, order)
 
 
 # include other

src/basis.jl

@@ -4,29 +4,29 @@ for (T, TP) in [(Cheb, ChebParams), (Lin, LinParams), (Spline, SplineParams)]
 end
 
 # params of same type are equal if all their fields are equal
-=={T<:BasisParams}(p1::T, p2::T) =
+==(p1::T, p2::T) where {T<:BasisParams} =
     all(map(nm->getfield(p1, nm) == getfield(p2, nm), fieldnames(p1)))::Bool
 
 # Bases of different dimension can't be equal
-=={T1<:BasisParams,T2<:BasisParams}(::T1, ::T2) = false
+==(::T1, ::T2) where {T1<:BasisParams,T2<:BasisParams} = false
 
 # ---------- #
 # Basis Type #
 # ---------- #
 
-type Basis{N,TP<:Tuple}
+mutable struct Basis{N,TP<:Tuple}
     params::TP     # params to construct basis
 end
 
 Base.min(b::Basis) = min.(b.params)
 Base.max(b::Basis) = max.(b.params)
-Base.ndims{N}(::Basis{N}) = N
-Base.ndims{N,TP}(::Type{Basis{N,TP}}) = N
+Base.ndims(::Basis{N}) where {N} = N
+Base.ndims(::Type{Basis{N,TP}}) where {N,TP} = N
 
-_get_TP{N,TP}(::Basis{N,TP}) = TP
-_get_TP{N,TP}(::Type{Basis{N,TP}}) = TP
+_get_TP(::Basis{N,TP}) where {N,TP} = TP
+_get_TP(::Type{Basis{N,TP}}) where {N,TP} = TP
 
-function Base.show{N}(io::IO, b::Basis{N})
+function Base.show(io::IO, b::Basis{N}) where N
     m = """
     $N dimensional Basis on the hypercube formed by $(min(b)) × $(max(b)).
     Basis families are $(join(string.(family_name.(b.params)), " × "))
@@ -75,9 +75,9 @@ end
 # fundefn type method
 Basis(bt::BasisFamily, n::Int, a, b) = Basis(_param(bt)(n, a, b))
 
-Basis{T<:BasisFamily}(::Type{T}, n::Int, a, b) = Basis(T(), n, a, b)
+Basis(::Type{T}, n::Int, a, b) where {T<:BasisFamily} = Basis(T(), n, a, b)
 
-Basis{T<:BasisFamily}(bt::T, n::Vector, a::Vector, b::Vector) =
+Basis(bt::T, n::Vector, a::Vector, b::Vector) where {T<:BasisFamily} =
     Basis(map(_param(T), n, a, b)...)
 
 # special method for Spline that adds `k` argument
@@ -90,23 +90,23 @@ Basis(::Spline, n::Vector, a::Vector, b::Vector, k::Vector=ones(Int, length(n)))
 # ----------------- #
 
 # separating Basis -- just re construct it from the nth set of params
-function Base.getindex{N}(basis::Basis{N}, n::Int)
+function Base.getindex(basis::Basis{N}, n::Int) where N
     n < 0 || n > N && error("n must be between 1 and $N")
     Basis(basis.params[n])::Basis{1}
 end
 
-_all_sparse{N,TP}(b::Basis{N,TP}) = all(issparse, TP.parameters)
+_all_sparse(b::Basis{N,TP}) where {N,TP} = all(issparse, TP.parameters)
 
 # other AbstractArray like methods for Basis
 Base.length(b::Basis) = prod(length, b.params)
 Base.size(b::Basis, i::Int) = length(b[i])  # uses method on previous line
-Base.size{N}(b::Basis{N}) = map(length, b.params)
+Base.size(b::Basis{N}) where {N} = map(length, b.params)
 
 # Bases of different dimension can't be equal
-=={N,M}(::Basis{N}, ::Basis{M}) = false
+==(::Basis{N}, ::Basis{M}) where {N,M} = false
 
 # basis are equal if all fields of the basis are equal
-=={N}(b1::Basis{N}, b2::Basis{N}) =
+==(b1::Basis{N}, b2::Basis{N}) where {N} =
     all(map(nm->getfield(b1, nm) == getfield(b2, nm), fieldnames(b1)))::Bool
 
 function nodes(b::Basis{1})
@@ -120,7 +120,7 @@ function nodes(b::Basis)  # funnode method
     return x, xcoord
 end
 
-@generated function bmat_type{N,TP,TO}(::Type{TO}, bm::Basis{N,TP}, x=1.0)
+@generated function bmat_type(::Type{TO}, bm::Basis{N,TP}, x=1.0) where {N,TP,TO}
     if N == 1
         out = bmat_type(TO, TP.parameters[1], x)
     else

src/basis_structure.jl

@@ -2,37 +2,37 @@
 # BasisMatrix Type #
 # ------------------- #
 
-@compat abstract type AbstractBasisMatrixRep end
+abstract type AbstractBasisMatrixRep end
 const ABSR = AbstractBasisMatrixRep
 
-immutable Tensor <: ABSR end
-immutable Direct <: ABSR end
-immutable Expanded <: ABSR end
+struct Tensor <: ABSR end
+struct Direct <: ABSR end
+struct Expanded <: ABSR end
 
-type BasisMatrix{BST<:ABSR, TM<:AbstractMatrix}
+mutable struct BasisMatrix{BST<:ABSR, TM<:AbstractMatrix}
     order::Matrix{Int}
     vals::Matrix{TM}
 end
 
-Base.show{BST}(io::IO, b::BasisMatrix{BST}) =
+Base.show(io::IO, b::BasisMatrix{BST}) where {BST} =
     print(io, "BasisMatrix{$BST} of order $(b.order)")
 
 Base.ndims(bs::BasisMatrix) = size(bs.order, 2)
 
 # not the same if either type parameter is different
-function =={BST1<:ABSR,BST2<:ABSR}(::BasisMatrix{BST1}, ::BasisMatrix{BST2})
+function ==(::BasisMatrix{BST1}, ::BasisMatrix{BST2}) where {BST1<:ABSR,BST2<:ABSR}
     false
 end
 
-function =={BST<:ABSR,TM1<:AbstractMatrix,TM2<:AbstractMatrix}(::BasisMatrix{BST,TM1},
-                                                               ::BasisMatrix{BST,TM2})
+function ==(::BasisMatrix{BST,TM1},
+            ::BasisMatrix{BST,TM2}) where {BST<:ABSR,TM1<:AbstractMatrix,TM2<:AbstractMatrix}
     false
 end
 
 # if type parameters are the same, then it is the same if all fields are the
 # same
-function =={BST<:ABSR,TM<:AbstractMatrix}(b1::BasisMatrix{BST,TM},
-                                          b2::BasisMatrix{BST,TM})
+function ==(b1::BasisMatrix{BST,TM},
+            b2::BasisMatrix{BST,TM}) where {BST<:ABSR,TM<:AbstractMatrix}
     b1.order == b2.order && b1.vals == b2.vals
 end
 
@@ -45,7 +45,7 @@ end
     x
 end
 
-@inline function _checkx{T}(N, x::AbstractVector{T})
+@inline function _checkx(N, x::AbstractVector{T}) where T
     # if we have a 1d basis, we can evaluate at each point
     if N == 1
         return x
@@ -132,11 +132,11 @@ end
 # --------------- #
 
 # no-op. Don't worry about the order argument.
-Base.convert{T<:ABSR}(::Type{T}, bs::BasisMatrix{T}, order=bs.order) = bs
+Base.convert(::Type{T}, bs::BasisMatrix{T}, order=bs.order) where {T<:ABSR} = bs
 
 # funbconv from direct to expanded
-function Base.convert{TM}(::Type{Expanded}, bs::BasisMatrix{Direct,TM},
-                      order=fill(0, 1, size(bs.order, 2)))
+function Base.convert(::Type{Expanded}, bs::BasisMatrix{Direct,TM},
+                  order=fill(0, 1, size(bs.order, 2))) where TM
     d, numbas, d1 = check_convert(bs, order)
 
     vals = Array{TM}(numbas, 1)
@@ -152,8 +152,8 @@ function Base.convert{TM}(::Type{Expanded}, bs::BasisMatrix{Direct,TM},
 end
 
 # funbconv from tensor to expanded
-function Base.convert{TM}(::Type{Expanded}, bs::BasisMatrix{Tensor,TM},
-                      order=fill(0, 1, size(bs.order, 2)))
+function Base.convert(::Type{Expanded}, bs::BasisMatrix{Tensor,TM},
+                  order=fill(0, 1, size(bs.order, 2))) where TM
     d, numbas, d1 = check_convert(bs, order)
 
     vals = Array{TM}(numbas, 1)
@@ -174,8 +174,8 @@ end
 #       plan on doing it much, this will do for now. The basic point is that
 #       we need to expand the rows of each element of `vals` so that all of
 #       them have prod([size(v, 1) for v in bs.vals])) rows.
-function Base.convert{TM}(::Type{Direct}, bs::BasisMatrix{Tensor,TM},
-                          order=fill(0, 1, size(bs.order, 2)))
+function Base.convert(::Type{Direct}, bs::BasisMatrix{Tensor,TM},
+                      order=fill(0, 1, size(bs.order, 2))) where TM
     d, numbas, d1 = check_convert(bs, order)
     vals = Array{TM}(numbas, d)
     raw_ind = Array{Vector{Int}}(d)
@@ -206,8 +206,8 @@ end
 
 # method to construct BasisMatrix in direct or expanded form based on
 # a matrix of `x` values  -- funbasex
-function BasisMatrix{N,BF,T2}(::Type{T2}, basis::Basis{N,BF}, ::Direct,
-                              x::AbstractArray=nodes(basis)[1], order=0)
+function BasisMatrix(::Type{T2}, basis::Basis{N,BF}, ::Direct,
+                     x::AbstractArray=nodes(basis)[1], order=0) where {N,BF,T2}
     m, order, minorder, numbases, x = check_basis_structure(N, x, order)
     # 76-77
     out_order = minorder
@@ -237,15 +237,15 @@ function BasisMatrix{N,BF,T2}(::Type{T2}, basis::Basis{N,BF}, ::Direct,
     BasisMatrix{Direct,val_type}(out_order, vals)
 end
 
-function BasisMatrix{T2}(::Type{T2}, basis::Basis, ::Expanded,
-                         x::AbstractArray=nodes(basis)[1], order=0)  # funbasex
+function BasisMatrix(::Type{T2}, basis::Basis, ::Expanded,
+                     x::AbstractArray=nodes(basis)[1], order=0) where T2  # funbasex
     # create direct form, then convert to expanded
     bsd = BasisMatrix(T2, basis, Direct(), x, order)
     convert(Expanded, bsd, bsd.order)
 end
 
-function BasisMatrix{N,BT,T2}(::Type{T2}, basis::Basis{N,BT}, ::Tensor,
-                              x::TensorX=nodes(basis)[2], order=0)
+function BasisMatrix(::Type{T2}, basis::Basis{N,BT}, ::Tensor,
+                     x::TensorX=nodes(basis)[2], order=0) where {N,BT,T2}
 
     m, order, minorder, numbases, x = check_basis_structure(N, x, order)
     out_order = minorder
@@ -276,29 +276,29 @@ end
 # When the user doesn't supply a ABSR, we pick one for them.
 # for x::AbstractMatrix we pick direct
 # for x::TensorX we pick Tensor
-function BasisMatrix{T2}(::Type{T2}, basis::Basis, x::AbstractArray, order=0)
+function BasisMatrix(::Type{T2}, basis::Basis, x::AbstractArray, order=0) where T2
     BasisMatrix(T2, basis, Direct(), x, order)
 end
 
-function BasisMatrix{T2}(::Type{T2}, basis::Basis, x::TensorX, order=0)
+function BasisMatrix(::Type{T2}, basis::Basis, x::TensorX, order=0) where T2
     BasisMatrix(T2, basis, Tensor(), x, order)
 end
 
 
 # method to allow passing types instead of instances of ABSR
-function BasisMatrix{BST<:ABSR,T2}(::Type{T2}, basis, ::Type{BST},
-                                   x::Union{AbstractArray,TensorX}, order=0)
+function BasisMatrix(::Type{T2}, basis, ::Type{BST},
+                     x::Union{AbstractArray,TensorX}, order=0) where {BST<:ABSR,T2}
     BasisMatrix(T2, basis, BST(), x, order)
 end
 
-function BasisMatrix{BST<:ABSR}(basis, ::Type{BST},
-                                x::Union{AbstractArray,TensorX}, order=0)
+function BasisMatrix(basis, ::Type{BST},
+                     x::Union{AbstractArray,TensorX}, order=0) where BST<:ABSR
     BasisMatrix(basis, BST(), x, order)
 end
 
 # method without vals eltypes
-function BasisMatrix{TBM<:ABSR}(basis::Basis, tbm::TBM,
-                                x::Union{AbstractArray,TensorX}, order=0)
+function BasisMatrix(basis::Basis, tbm::TBM,
+                     x::Union{AbstractArray,TensorX}, order=0) where TBM<:ABSR
     BasisMatrix(Void, basis, tbm, x, order)
 end
 
@@ -307,6 +307,6 @@ function BasisMatrix(basis::Basis, x::Union{AbstractArray,TensorX}, order=0)
 end
 
 # method without x
-function BasisMatrix{TBM<:ABSR}(basis::Basis, tbm::Union{Type{TBM},TBM})
+function BasisMatrix(basis::Basis, tbm::Union{Type{TBM},TBM}) where TBM<:ABSR
     BasisMatrix(Void, basis, tbm)
 end