Add fallbacks with old interface

Author: tomasaschan

src/Interpolations.jl

@@ -32,9 +32,10 @@ using WoodburyMatrices, Ratios, AxisAlgorithms
 
 import Base: convert, size, getindex, gradient, scale, promote_rule
 
-abstract InterpolationType
+abstract Flag
+abstract InterpolationType <: Flag
 immutable NoInterp <: InterpolationType end
-abstract GridType
+abstract GridType <: Flag
 immutable OnGrid <: GridType end
 immutable OnCell <: GridType end
 
@@ -44,16 +45,16 @@ abstract AbstractInterpolation{T,N,IT<:DimSpec{InterpolationType},GT<:DimSpec{Gr
 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}
 
-abstract BoundaryCondition
-immutable Flat <: BoundaryCondition end
-immutable Line <: BoundaryCondition end
-immutable Free <: BoundaryCondition end
-immutable Periodic <: BoundaryCondition end
-immutable Reflect <: BoundaryCondition end
-immutable InPlace <: BoundaryCondition end
+immutable Throw <: Flag end
+immutable Flat <: Flag end
+immutable Line <: Flag end
+immutable Free <: Flag end
+immutable Periodic <: Flag end
+immutable Reflect <: Flag end
+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 <: BoundaryCondition end
+immutable InPlaceQ <: Flag end
 typealias Natural Line
 
 # TODO: size might have to be faster?

src/b-splines/b-splines.jl

@@ -6,7 +6,7 @@ export
     Linear,
     Quadratic
 
-abstract Degree{N}
+abstract Degree{N} <: Flag
 
 immutable BSpline{D<:Degree} <: InterpolationType end
 BSpline{D<:Degree}(::D) = BSpline{D}()

src/b-splines/quadratic.jl

@@ -1,5 +1,5 @@
-immutable Quadratic{BC<:BoundaryCondition} <: Degree{2} end
-Quadratic{BC<:BoundaryCondition}(::BC) = Quadratic{BC}()
+immutable Quadratic{BC<:Flag} <: Degree{2} end
+Quadratic{BC<:Flag}(::BC) = Quadratic{BC}()
 
 function define_indices_d{BC}(::Type{BSpline{Quadratic{BC}}}, d, pad)
     symix, symixm, symixp = symbol("ix_",d), symbol("ixm_",d), symbol("ixp_",d)
@@ -73,7 +73,7 @@ function index_gen{Q<:Quadratic,IT<:DimSpec{BSpline}}(::Type{BSpline{Q}}, ::Type
     end
 end
 
-padding{BC<:BoundaryCondition}(::Type{BSpline{Quadratic{BC}}}) = Val{1}()
+padding{BC<:Flag}(::Type{BSpline{Quadratic{BC}}}) = Val{1}()
 padding(::Type{BSpline{Quadratic{Periodic}}}) = Val{0}()
 
 function inner_system_diags{T,Q<:Quadratic}(::Type{T}, n::Int, ::Type{Q})

src/extrapolation/extrapolation.jl

@@ -1,11 +1,15 @@
-export Throw
-
 type Extrapolation{T,N,ITPT,IT,GT,ET} <: AbstractInterpolationWrapper{T,N,ITPT,IT,GT}
     itp::ITPT
 end
 Extrapolation{T,ITPT,IT,GT,ET}(::Type{T}, N, itp::ITPT, ::Type{IT}, ::Type{GT}, et::ET) =
     Extrapolation{T,N,ITPT,IT,GT,ET}(itp)
 
+# DimSpec{Flag} is not enough for extrapolation dispatch, since we allow nested tuples
+# 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}}}}}
+
 """
 `extrapolate(itp, scheme)` adds extrapolation behavior to an interpolation object, according to the provided scheme.
 
@@ -21,7 +25,7 @@ You can also combine schemes in tuples. For example, the scheme `(Linear(), Flat
 
 Finally, you can specify different extrapolation behavior in different direction. `((Linear(),Flat()), Flat())` will extrapolate linearly in the first dimension if the index is too small, but use constant etrapolation if it is too large, and always use constant extrapolation in the second dimension.
 """
-extrapolate{T,N,IT,GT}(itp::AbstractInterpolation{T,N,IT,GT}, et) =
+extrapolate{T,N,IT,GT,ET<:ExtrapDimSpec}(itp::AbstractInterpolation{T,N,IT,GT}, et::ET) =
     Extrapolation(T,N,itp,IT,GT,et)
 
 include("throw.jl")

src/extrapolation/throw.jl

@@ -1,5 +1,3 @@
-immutable Throw end
-
 function extrap_prep{N,d}(::Type{Throw}, ::Val{N}, ::Val{d})
     xsym = symbol("xs_", d)
     :(lbound(etp, $d) <= $xsym <= ubound(etp, $d) || throw(BoundsError()))

test/extrapolation/runtests.jl

@@ -14,7 +14,7 @@ etpg = extrapolate(itpg, Flat())
 @test etpg[-3] == etpg[-4.5] == etpg[0.9] == etpg[1.0] == A[1]
 @test etpg[10.1] == etpg[11] == etpg[148.298452] == A[end]
 
-etpf = @inferred(extrapolate(itpg, FillValue(NaN)))
+etpf = @inferred(extrapolate(itpg, NaN))
 
 @test @inferred(size(etpf)) == (xmax,)
 @test isnan(@inferred(getindex(etpf, -2.5)))

test/type-instantiation.jl

@@ -0,0 +1,78 @@
+module TypeInstantiationTests
+
+using Interpolations, Base.Test
+
+# NO DIMSPECS
+# tests that we forward types correctly to the instance constructors
+const A1 = rand(15)
+const A2 = rand(15, 10)
+
+# B-splines
+for GT in (OnCell, OnGrid)
+    # ...without boundary conditions
+    for D in (Constant, Linear)
+        @inferred(interpolate(A1, BSpline(D), GT))
+        @inferred(interpolate(A1, BSpline(D), GT()))
+        @inferred(interpolate(A1, BSpline(D()), GT))
+        @inferred(interpolate(A2, BSpline(D), GT))
+        @inferred(interpolate(A2, BSpline(D), GT()))
+        @inferred(interpolate(A2, BSpline(D()), GT))
+
+        @inferred(interpolate!(copy(A1), BSpline(D), GT))
+        @inferred(interpolate!(copy(A1), BSpline(D), GT()))
+        @inferred(interpolate!(copy(A1), BSpline(D()), GT))
+        @inferred(interpolate!(copy(A2), BSpline(D), GT))
+        @inferred(interpolate!(copy(A2), BSpline(D), GT()))
+        @inferred(interpolate!(copy(A2), BSpline(D()), GT))
+    end
+
+    # Quadratic
+    for BC in (Flat, Line, Periodic, Reflect, Free)
+        if BC != InPlace
+            @inferred(interpolate(A1, BSpline(Quadratic(BC)), GT))
+            @inferred(interpolate(A1, BSpline(Quadratic(BC())), GT))
+            @inferred(interpolate(A1, BSpline(Quadratic(BC)), GT()))
+            @inferred(interpolate(A2, BSpline(Quadratic(BC)), GT))
+            @inferred(interpolate(A2, BSpline(Quadratic(BC())), GT))
+            @inferred(interpolate(A2, BSpline(Quadratic(BC)), GT()))
+        end
+
+        @inferred(interpolate!(copy(A1), BSpline(Quadratic(BC)), GT))
+        @inferred(interpolate!(copy(A1), BSpline(Quadratic(BC())), GT))
+        @inferred(interpolate!(copy(A1), BSpline(Quadratic(BC)), GT()))
+        @inferred(interpolate!(copy(A2), BSpline(Quadratic(BC)), GT))
+        @inferred(interpolate!(copy(A2), BSpline(Quadratic(BC())), GT))
+        @inferred(interpolate!(copy(A2), BSpline(Quadratic(BC)), GT()))
+    end
+end
+
+# Gridded
+const knots1 = (sort(rand(15)),)
+const knots2 = (sort(rand(15)), sort(rand(10)))
+for D in (Constant, Linear)
+    @inferred(interpolate(knots1, A1, Gridded(D)))
+    @inferred(interpolate(knots2, A2, Gridded(D)))
+
+    @inferred(interpolate!(knots1, copy(A1), Gridded(D)))
+    @inferred(interpolate!(knots2, copy(A2), Gridded(D)))
+end
+
+# DIMSPECS
+
+# test that constructing dimspecs work
+for T in (
+    Tuple{OnGrid,OnCell},
+    Tuple{BSpline{Linear},BSpline{Quadratic{Free}}}
+    )
+    @test isa(@inferred(Interpolations.construct_instance(T)), T)
+end
+# sample one dimspec for each interpolation constructor to see that it
+# calls the construct_instance() function correctly
+@inferred(interpolate(A2, Tuple{BSpline{Linear},BSpline{Constant}}, Tuple{OnGrid,OnCell}))
+@inferred(interpolate!(copy(A2), Tuple{BSpline{Linear},BSpline{Constant}}, Tuple{OnGrid,OnCell}))
+@inferred(interpolate(A2, Tuple{BSpline{Linear},BSpline{Constant}}, (OnGrid(),OnCell())))
+@inferred(interpolate!(copy(A2), Tuple{BSpline{Linear},BSpline{Constant}}, (OnGrid(),OnCell())))
+@inferred(interpolate(A2, (BSpline(Linear()),BSpline(Constant())), Tuple{OnGrid,OnCell}))
+@inferred(interpolate!(copy(A2), (BSpline(Linear()),BSpline(Constant())), Tuple{OnGrid,OnCell}))
+
+end