Don't pretend to be more generic than is possible

Author: timholy

src/Interpolations.jl

@@ -77,28 +77,20 @@ const Natural = Line
 
 Base.IndexStyle(::Type{<:AbstractInterpolation}) = IndexCartesian()
 
-size(itp::AbstractInterpolation) = map(length, itp.parentaxes)
 size(exp::AbstractExtrapolation) = size(exp.itp)
-axes(itp::AbstractInterpolation) = itp.parentaxes
 axes(exp::AbstractExtrapolation) = axes(exp.itp)
 
-bounds(itp::AbstractInterpolation) = map(twotuple, lbounds(itp), ubounds(itp))
 twotuple(r::AbstractUnitRange) = (first(r), last(r))
 twotuple(x, y) = (x, y)
+bounds(itp::AbstractInterpolation) = map(twotuple, lbounds(itp), ubounds(itp))
 bounds(itp::AbstractInterpolation, d) = bounds(itp)[d]
-lbounds(itp::AbstractInterpolation) = _lbounds(itp.parentaxes, itpflag(itp), gridflag(itp))
-ubounds(itp::AbstractInterpolation) = _ubounds(itp.parentaxes, itpflag(itp), gridflag(itp))
-_lbounds(axs::NTuple{N,Any}, itp, gt) where N = ntuple(d->lbound(axs[d], iextract(itp,d), iextract(gt,d)), Val(N))
-_ubounds(axs::NTuple{N,Any}, itp, gt) where N = ntuple(d->ubound(axs[d], iextract(itp,d), iextract(gt,d)), Val(N))
 
 itptype(::Type{AbstractInterpolation{T,N,IT,GT}}) where {T,N,IT<:DimSpec{InterpolationType},GT<:DimSpec{GridType}} = IT
 itptype(::Type{ITP}) where {ITP<:AbstractInterpolation} = itptype(supertype(ITP))
 itptype(itp::AbstractInterpolation) = itptype(typeof(itp))
-itpflag(itp::AbstractInterpolation) = itp.it
 gridtype(::Type{AbstractInterpolation{T,N,IT,GT}}) where {T,N,IT<:DimSpec{InterpolationType},GT<:DimSpec{GridType}} = GT
 gridtype(::Type{ITP}) where {ITP<:AbstractInterpolation} = gridtype(supertype(ITP))
 gridtype(itp::AbstractInterpolation) = gridtype(typeof(itp))
-gridflag(itp::AbstractInterpolation) = itp.gt
 ndims(::Type{AbstractInterpolation{T,N,IT,GT}}) where {T,N,IT<:DimSpec{InterpolationType},GT<:DimSpec{GridType}} = N
 ndims(::Type{ITP}) where {ITP<:AbstractInterpolation} = ndims(supertype(ITP))
 ndims(itp::AbstractInterpolation) = ndims(typeof(itp))
@@ -184,7 +176,7 @@ Base.to_index(::AbstractInterpolation, x::Number) = x
 
 # Commented out because you can't add methods to an abstract type.
 # @inline function (itp::AbstractInterpolation)(x::Vararg{UnexpandedIndexTypes})
-#     itp(to_indices(itp, x))
+#     itp(to_indices(itp, x)...)
 # end
 function gradient(itp::AbstractInterpolation, x::Vararg{UnexpandedIndexTypes})
     gradient(itp, to_indices(itp, x)...)

src/b-splines/b-splines.jl

@@ -45,6 +45,16 @@ coefficients(itp::BSplineInterpolation) = itp.coefs
 interpdegree(itp::BSplineInterpolation) = interpdegree(itpflag(itp))
 interpdegree(::BSpline{T}) where T = T()
 interpdegree(it::Tuple{Vararg{Union{BSpline,NoInterp},N}}) where N = interpdegree.(it)
+itpflag(itp::BSplineInterpolation) = itp.it
+gridflag(itp::BSplineInterpolation) = itp.gt
+
+size(itp::BSplineInterpolation) = map(length, itp.parentaxes)
+axes(itp::BSplineInterpolation) = itp.parentaxes
+
+lbounds(itp::BSplineInterpolation) = _lbounds(itp.parentaxes, itpflag(itp), gridflag(itp))
+ubounds(itp::BSplineInterpolation) = _ubounds(itp.parentaxes, itpflag(itp), gridflag(itp))
+_lbounds(axs::NTuple{N,Any}, itp, gt) where N = ntuple(d->lbound(axs[d], iextract(itp,d), iextract(gt,d)), Val(N))
+_ubounds(axs::NTuple{N,Any}, itp, gt) where N = ntuple(d->ubound(axs[d], iextract(itp,d), iextract(gt,d)), Val(N))
 
 # The unpadded defaults
 lbound(ax, ::BSpline, ::OnCell) = first(ax) - 0.5

src/b-splines/indexing.jl

@@ -4,10 +4,10 @@
     @boundscheck (checkbounds(Bool, itp, x...) || Base.throw_boundserror(itp, x))
     expand_value(itp, x)
 end
-@inline function (itp::BSplineInterpolation{T,1})(x::Integer, y::Integer) where T
-    @boundscheck (y == 1 || Base.throw_boundserror(itp, (x,y)))
-    expand_value(itp, (x,))
-end
+# @inline function (itp::BSplineInterpolation{T,1})(x::Integer, y::Integer) where T
+#     @boundscheck (y == 1 || Base.throw_boundserror(itp, (x,y)))
+#     expand_value(itp, (x,))
+# end
 
 @inline function gradient(itp::BSplineInterpolation{T,N}, x::Vararg{Number,N}) where {T,N}
     @boundscheck checkbounds(Bool, itp, x...) || Base.throw_boundserror(itp, x)