Allow a tuple to be passed with scale, Fix #528, #535 (#534)

* Allow a tuple to be passed with scale

* Remove tests for Julia 1.0

* Fix #535 warn

* Add 1.6 tests, default constructors

* Use approx in test

Author: mkitti

.github/workflows/CI.yml

@@ -13,8 +13,8 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.0'
           - '1.3'
+          - '1.6'
           - '1'
           - 'nightly'
         os:

Project.toml

@@ -25,7 +25,7 @@ Ratios = "0.3, 0.4"
 Requires = "1.1"
 StaticArrays = "0.12, 1"
 WoodburyMatrices = "0.4, 0.5"
-julia = "1"
+julia = "1.3"
 
 [extras]
 ColorVectorSpace = "c3611d14-8923-5661-9e6a-0046d554d3a4"

src/b-splines/b-splines.jl

@@ -20,6 +20,8 @@ struct BSpline{D<:Degree} <: InterpolationType
     degree::D
 end
 
+BSpline(::Type{D}) where D <: Degree = BSpline(D())
+
 bsplinetype(::Type{BSpline{D}}) where {D<:Degree} = D
 bsplinetype(::BS) where {BS<:BSpline} = bsplinetype(BS)
 

src/b-splines/constant.jl

@@ -41,6 +41,7 @@ Constant(args...) = Constant{Nearest}(args...)
 Constant{T}() where {T<:ConstantInterpType} = Constant{T,Throw{OnGrid}}(Throw(OnGrid()))
 Constant{T}(bc::BC) where {T<:ConstantInterpType,BC<:BoundaryCondition} = Constant{T,BC}(bc)
 Constant{T}(::Periodic{Nothing}) where {T<:ConstantInterpType} = Constant{T,Periodic{OnCell}}(Periodic(OnCell()))
+Constant(::Type{T}) where T <: ConstantInterpType = Constant{T}()
 
 function Base.show(io::IO, deg::Constant)
     print(io, nameof(typeof(deg)), '{', typeof(deg).parameters[1], '}', '(')

src/b-splines/cubic.jl

@@ -3,6 +3,8 @@ struct Cubic{BC<:BoundaryCondition} <: DegreeBC{3}
 end
 
 (deg::Cubic)(gt::GridType) = Cubic(deg.bc(gt))
+# Default constructor to match cubic_spline_interpolation
+Cubic() = Cubic(Line(OnGrid()))
 
 """
     Cubic(bc::BoundaryCondition)

src/b-splines/quadratic.jl

@@ -1,6 +1,8 @@
 struct Quadratic{BC<:BoundaryCondition} <: DegreeBC{2}
     bc::BC
 end
+# Default constructor
+Quadratic() = Quadratic(Line(OnGrid()))
 (deg::Quadratic)(gt::GridType) = Quadratic(deg.bc(gt))
 
 

src/monotonic/monotonic.jl

@@ -154,7 +154,7 @@ function MonotonicInterpolation(::Type{TWeights}, it::TInterpolationType, knots:
     m::Vector{TCoeffs1}, c::Vector{TCoeffs2}, d::Vector{TCoeffs3}) where {TWeights, TCoeffs1, TCoeffs2, TCoeffs3, TEl, TInterpolationType<:MonotonicInterpolationType, TKnots<:AbstractVector{<:Number}}
 
     isconcretetype(TInterpolationType) || error("The spline type must be a leaf type (was $TInterpolationType)")
-    isconcretetype(tcoef(A)) || warn("For performance reasons, consider using an array of a concrete type (eltype(A) == $(eltype(A)))")
+    isconcretetype(tcoef(A)) || @warn("For performance reasons, consider using an array of a concrete type (eltype(A) == $(eltype(A)))")
 
     check_monotonic(knots, A)
 

src/scaling/scaling.jl

@@ -28,6 +28,7 @@ function scale(itp::AbstractInterpolation{T,N,IT}, ranges::Vararg{AbstractRange,
     check_ranges(itpflag(itp), axes(itp), ranges)
     ScaledInterpolation{T,N,typeof(itp),IT,typeof(ranges)}(itp, ranges)
 end
+scale(itp::AbstractInterpolation{T,N,IT}, ranges::NTuple{N, <:AbstractRange}) where {T,N,IT} = scale(itp, ranges...)
 
 function check_ranges(flags, axs, ranges)
     check_range(getfirst(flags), axs[1], ranges[1])

test/b-splines/constant.jl

@@ -10,6 +10,8 @@
         for T in (Nearest, Previous, Next)
             it = Constant{T}()
             @test it isa Constant{T}
+            it = T |> Constant
+            @test it isa Constant{T}
         end
     end
 

test/b-splines/cubic.jl

@@ -50,6 +50,11 @@
         end
     end
 
+    # Test default constructor
+    itp_type = Cubic |> BSpline
+    itp = interpolate(1:5, itp_type)
+    @test itp(1:0.5:5) ≈ 1:0.5:5
+
     ix = 1:15
     k = length(ix) - 1
     f(x) = cos((x-1)*2pi/k)