Apply compat updates for Julia 0.6 (#139)

Apply compat updates for Julia 0.6

Author: ararslan

REQUIRE

@@ -3,5 +3,5 @@ julia 0.4
 WoodburyMatrices 0.1.5
 Ratios
 AxisAlgorithms
-Compat 0.8.0
+Compat 0.19.0
 DualNumbers

src/Interpolations-old.jl

@@ -36,26 +36,26 @@ export
     gradient,
     gradient!
 
-abstract Degree{N}
+@compat abstract type Degree{N} end
 
-abstract GridRepresentation
+@compat abstract type GridRepresentation end
 immutable OnGrid <: GridRepresentation end
 immutable OnCell <: GridRepresentation end
 
-abstract BoundaryCondition
+@compat abstract type BoundaryCondition end
 immutable None <: BoundaryCondition end
 immutable Flat <: BoundaryCondition end
 immutable Line <: BoundaryCondition end
-typealias Natural Line
+const Natural = Line
 immutable Free <: BoundaryCondition end
 immutable Periodic <: BoundaryCondition end
 immutable Reflect <: BoundaryCondition end
 
-abstract InterpolationType{D<:Degree,BC<:BoundaryCondition,GR<:GridRepresentation}
+@compat abstract type InterpolationType{D<:Degree,BC<:BoundaryCondition,GR<:GridRepresentation} end
 
 include("extrapolation.jl")
 
-abstract AbstractInterpolation{T,N,IT<:InterpolationType,EB<:ExtrapolationBehavior} <: AbstractArray{T,N}
+@compat abstract type AbstractInterpolation{T,N,IT<:InterpolationType,EB<:ExtrapolationBehavior} <: AbstractArray{T,N} end
 type Interpolation{T,N,TCoefs,IT<:InterpolationType,EB<:ExtrapolationBehavior} <: AbstractInterpolation{T,N,IT,EB}
     coefs::Array{TCoefs,N}
 end
@@ -258,4 +258,4 @@ end
 
 nindexes(N::Int) = N == 1 ? "1 index" : "$N indexes"
 
-end # module
+end # module

src/Interpolations.jl

@@ -43,18 +43,18 @@ import Base: convert, size, getindex, gradient, promote_rule, ndims, eltype
 if isdefined(:scaling) import Base.scaling end
 if isdefined(:scale) import Base.scale end
 
-abstract Flag
-abstract InterpolationType <: Flag
+@compat abstract type Flag end
+@compat abstract type InterpolationType <: Flag end
 immutable NoInterp <: InterpolationType end
-abstract GridType <: Flag
+@compat abstract type GridType <: Flag end
 immutable OnGrid <: GridType end
 immutable OnCell <: GridType end
 
-typealias DimSpec{T} Union{T,Tuple{Vararg{Union{T,NoInterp}}},NoInterp}
+@compat const DimSpec{T} = Union{T,Tuple{Vararg{Union{T,NoInterp}}},NoInterp}
 
-abstract AbstractInterpolation{T,N,IT<:DimSpec{InterpolationType},GT<:DimSpec{GridType}} <: AbstractArray{T,N}
-abstract AbstractInterpolationWrapper{T,N,ITPT,IT,GT} <: AbstractInterpolation{T,N,IT,GT}
-abstract AbstractExtrapolation{T,N,ITPT,IT,GT} <: AbstractInterpolationWrapper{T,N,ITPT,IT,GT}
+@compat abstract type AbstractInterpolation{T,N,IT<:DimSpec{InterpolationType},GT<:DimSpec{GridType}} <: AbstractArray{T,N} end
+@compat abstract type AbstractInterpolationWrapper{T,N,ITPT,IT,GT} <: AbstractInterpolation{T,N,IT,GT} end
+@compat abstract type AbstractExtrapolation{T,N,ITPT,IT,GT} <: AbstractInterpolationWrapper{T,N,ITPT,IT,GT} end
 
 immutable Throw <: Flag end
 immutable Flat <: Flag end
@@ -66,7 +66,7 @@ immutable InPlace <: Flag end
 # InPlaceQ is exact for an underlying quadratic. This is nice for ground-truth testing
 # of in-place (unpadded) interpolation.
 immutable InPlaceQ <: Flag end
-typealias Natural Line
+const Natural = Line
 
 @generated size{T, N}(itp::AbstractInterpolation{T,N}) = Expr(:tuple, [:(size(itp, $i)) for i in 1:N]...)
 size(exp::AbstractExtrapolation, d) = size(exp.itp, d)

src/b-splines/b-splines.jl

@@ -7,7 +7,7 @@ export
     Quadratic,
     Cubic
 
-abstract Degree{N} <: Flag
+@compat abstract type Degree{N} <: Flag end
 
 immutable BSpline{D<:Degree} <: InterpolationType end
 BSpline{D<:Degree}(::D) = BSpline{D}()
@@ -84,4 +84,4 @@ include("quadratic.jl")
 include("cubic.jl")
 include("indexing.jl")
 include("prefiltering.jl")
-include("../filter1d.jl")
+include("../filter1d.jl")

src/b-splines/indexing.jl

@@ -3,7 +3,7 @@ using DualNumbers
 
 import Base.getindex
 
-Base.linearindexing{T<:AbstractInterpolation}(::Type{T}) = Base.LinearSlow()
+@compat Base.IndexStyle(::Type{<:AbstractInterpolation}) = IndexCartesian()
 
 define_indices{IT}(::Type{IT}, N, pad) = Expr(:block, Expr[define_indices_d(iextract(IT, d), d, padextract(pad, d)) for d = 1:N]...)
 

src/extrapolation/extrapolation.jl

@@ -8,7 +8,7 @@ Extrapolation{T,ITPT,IT,GT,ET}(::Type{T}, N, itp::ITPT, ::Type{IT}, ::Type{GT},
 # However, no tuples should be nested deeper than this; the first level is for different
 # schemes in different dimensions, and the second level is for different schemes in
 # different directions.
-typealias ExtrapDimSpec Union{Flag,Tuple{Vararg{Union{Flag,NTuple{2,Flag}}}}}
+const ExtrapDimSpec = Union{Flag,Tuple{Vararg{Union{Flag,NTuple{2,Flag}}}}}
 
 """
 `extrapolate(itp, scheme)` adds extrapolation behavior to an interpolation object, according to the provided scheme.
@@ -77,4 +77,4 @@ lbound(etp::Extrapolation, d) = lbound(etp.itp, d)
 ubound(etp::Extrapolation, d) = ubound(etp.itp, d)
 size(etp::Extrapolation, d) = size(etp.itp, d)
 
-include("filled.jl")
+include("filled.jl")

src/gridded/gridded.jl

@@ -5,7 +5,7 @@ Gridded{D<:Degree}(::D) = Gridded{D}()
 
 griddedtype{D<:Degree}(::Type{Gridded{D}}) = D
 
-typealias GridIndex{T} Union{AbstractVector{T}, Tuple}
+@compat const GridIndex{T} = Union{AbstractVector{T}, Tuple}
 
 # Because Ranges check bounds on getindex, it's actually faster to convert the
 # knots to Vectors. It's also good to take a copy, so it doesn't get modified later.
@@ -65,4 +65,4 @@ ubound(itp::GriddedInterpolation, d) = itp.knots[d][end]
 
 include("constant.jl")
 include("linear.jl")
-include("indexing.jl")
+include("indexing.jl")

src/scaling/scaling.jl

@@ -98,7 +98,7 @@ end
 rescale_gradient(r::StepRange, g) = g / r.step
 rescale_gradient(r::UnitRange, g) = g
 
-@static if isdefined(:FloatRange) & isa(FloatRange, DataType)
+@static if isdefined(Base, :FloatRange) && VERSION < v"0.6.0-dev.2376"
     rescale_gradient(r::LinSpace, g) = g * r.divisor / (r.stop - r.start)
     rescale_gradient(r::FloatRange, g) = g * r.divisor / r.step
     coordlookup(r::LinSpace, x) = (r.divisor * x + r.stop - r.len * r.start) / (r.stop - r.start)

test/b-splines/linear.jl

@@ -14,15 +14,15 @@ g2(y) = cos(y/6)
 f(x,y) = g1(x)*g2(y)
 A2 = Float64[f(x,y) for x in 1:xmax, y in 1:ymax]
 
-for (constructor, copier) in ((interpolate, _->_), (interpolate!, copy))
+for (constructor, copier) in ((interpolate, identity), (interpolate!, copy))
     itp1c = @inferred(constructor(copier(A1), BSpline(Linear()), OnCell()))
 
     # Just interpolation
     for x in 1:.2:xmax
         @test ≈(f(x),itp1c[x],atol=abs(0.1 * f(x)))
     end
 
-    # Rational element types    
+    # Rational element types
     A1R = Rational{Int}[fr(x) for x in 1:10]
     itp1r = @inferred(constructor(copier(A1R), BSpline(Linear()), OnGrid()))
     @test @inferred(size(itp1r)) == size(A1R)
@@ -39,4 +39,4 @@ for (constructor, copier) in ((interpolate, _->_), (interpolate!, copy))
     end
 end
 
-end
+end