Merge branch 'master' into master

mkitti · web-flow · commit e9b99cf646f7 · 2020-10-18T23:29:44.000-04:00
diff --git a/README.md b/README.md
@@ -1,29 +1,21 @@
 # Interpolations
 
 [![Build Status](https://travis-ci.org/JuliaMath/Interpolations.jl.svg?branch=master)](https://travis-ci.org/JuliaMath/Interpolations.jl)
-[![PkgEval Status](http://pkg.julialang.org/badges/Interpolations_0.4.svg)](http://pkg.julialang.org/?pkg=Interpolations)
-[![Interpolations](http://pkg.julialang.org/badges/Interpolations_0.5.svg)](http://pkg.julialang.org/?pkg=Interpolations)
-
-Documentation:
 [![](https://img.shields.io/badge/docs-latest-blue.svg)](http://juliamath.github.io/Interpolations.jl/latest)
 
+**NEWS** This package is currently under new maintainership. Please be patient while the new maintainer learns the new package. If you would like to volunteer, please mention this in an issue.
 
 **NEWS** v0.9 was a breaking release. See the [news](NEWS.md) for details on how to update.
 
-**NEWS** This package is officially looking for a maintainer.
-The original authors are only fixing bugs that affect them personally.
-However, to facilitate transition to a long-term maintainer,
-for a period of time they will make a concerted attempt to review pull requests.
-Step forward soon to avoid the risk of not being able to take advantage of such offers of support.
-
 This package implements a variety of interpolation schemes for the
 Julia language.  It has the goals of ease-of-use, broad algorithmic
 support, and exceptional performance.
 
 Currently this package's support is best
 for [B-splines](https://en.wikipedia.org/wiki/B-spline) and also
 supports irregular grids.  However, the API has been designed with
-intent to support more options. Pull-requests are more than welcome!
+intent to support more options. Initial support for Lanczos
+interpolation was recently added. Pull-requests are more than welcome!
 It should be noted that the API may continue to evolve over time.
 
 Other interpolation packages for Julia include:
@@ -122,6 +114,6 @@ Interpolations wins in every case, sometimes by a very large margin.
 
 ## Contributing
 
-Work is very much in progress, but and help is always welcome. If you want to help out but don't know where to start, take a look at issue [#5 - our feature wishlist](https://github.com/JuliaMath/Interpolations.jl/issues/5) =) There is also some [developer documentation](doc/devdocs.md) that may help you understand how things work internally.
+Work is very much in progress, but and help is always welcome. If you want to help out but don't know where to start, take a look at issue [#5 - our feature wishlist](https://github.com/JuliaMath/Interpolations.jl/issues/5) =) There is also some [developer documentation](http://juliamath.github.io/Interpolations.jl/latest/devdocs/) that may help you understand how things work internally.
 
 Contributions in any form are appreciated, but the best pull requests come with tests!
diff --git a/src/extrapolation/extrapolation.jl b/src/extrapolation/extrapolation.jl
@@ -53,8 +53,7 @@ count_interp_dims(::Type{<:Extrapolation{T,N,ITPT}}, n) where {T,N,ITPT} = count
 end
 @inline function (etp::Extrapolation{T,N})(x::Vararg{Union{Number,AbstractVector},N}) where {T,N}
     itp = parent(etp)
-    Tret = typeof(lispyprod(zero(T), x...))
-    ret = zeros(Tret, shape(x...))
+    ret = zeros(T, shape(x...))
     for (i, y) in zip(eachindex(ret), Iterators.product(x...))
         ret[i] = etp(y...)
     end
diff --git a/test/extrapolation/type-stability.jl b/test/extrapolation/type-stability.jl
@@ -69,4 +69,10 @@ using Test, Interpolations, DualNumbers, Unitful
     @test @inferred(itp(2018)) === 2.0f0 * u
     @test @inferred(etp(2018)) === 2.0f0 * u
     @test @inferred(etp(2019)) === 1.0f0 * u
+
+    # Unitful vector knots
+    t = [0.0, 1.0] * u"m"
+    itp = LinearInterpolation(t, y)
+    @test itp(0.5u"m") == 1.5f0 * u
+    @test itp([0.5, 0.75]u"m") == [1.5f0, 1.75f0] * u
 end
diff --git a/test/io.jl b/test/io.jl
@@ -8,38 +8,47 @@ using Test
         A = rand(8,20)
 
         itp = interpolate(A, BSpline(Constant()))
-        @test summary(itp) == "8×20 interpolate(::Array{Float64,2}, BSpline(Constant())) with element type Float64"
+        @test summary(itp) == "8×20 interpolate(::Matrix{Float64}, BSpline(Constant())) with element type Float64" ||
+              summary(itp) == "8×20 interpolate(::Array{Float64,2}, BSpline(Constant())) with element type Float64"
 
         itp = interpolate(A, BSpline(Constant()))
-        @test summary(itp) == "8×20 interpolate(::Array{Float64,2}, BSpline(Constant())) with element type Float64"
+        @test summary(itp) == "8×20 interpolate(::Matrix{Float64}, BSpline(Constant())) with element type Float64" ||
+              summary(itp) == "8×20 interpolate(::Array{Float64,2}, BSpline(Constant())) with element type Float64"
 
         itp = interpolate(A, BSpline(Linear()))
-        @test summary(itp) == "8×20 interpolate(::Array{Float64,2}, BSpline(Linear())) with element type Float64"
+        @test summary(itp) == "8×20 interpolate(::Matrix{Float64}, BSpline(Linear())) with element type Float64" ||
+              summary(itp) == "8×20 interpolate(::Array{Float64,2}, BSpline(Linear())) with element type Float64"
 
         itp = interpolate(A, BSpline(Quadratic(Reflect(OnCell()))))
-        @test summary(itp) == "8×20 interpolate(OffsetArray(::Array{Float64,2}, 0:9, 0:21), BSpline(Quadratic(Reflect(OnCell())))) with element type Float64"
+        @test summary(itp) == "8×20 interpolate(OffsetArray(::Matrix{Float64}, 0:9, 0:21), BSpline(Quadratic(Reflect(OnCell())))) with element type Float64" ||
+              summary(itp) == "8×20 interpolate(OffsetArray(::Array{Float64,2}, 0:9, 0:21), BSpline(Quadratic(Reflect(OnCell())))) with element type Float64"
 
         itp = interpolate(A, (BSpline(Linear()), NoInterp()))
-        @test summary(itp) == "8×20 interpolate(::Array{Float64,2}, (BSpline(Linear()), NoInterp())) with element type Float64"
+        @test summary(itp) == "8×20 interpolate(::Matrix{Float64}, (BSpline(Linear()), NoInterp())) with element type Float64" ||
+              summary(itp) == "8×20 interpolate(::Array{Float64,2}, (BSpline(Linear()), NoInterp())) with element type Float64"
 
         itp = interpolate!(copy(A), BSpline(Quadratic(InPlace(OnCell()))))
-        @test summary(itp) == "8×20 interpolate(::Array{Float64,2}, BSpline(Quadratic(InPlace(OnCell())))) with element type Float64"
+        @test summary(itp) == "8×20 interpolate(::Matrix{Float64}, BSpline(Quadratic(InPlace(OnCell())))) with element type Float64" ||
+              summary(itp) == "8×20 interpolate(::Array{Float64,2}, BSpline(Quadratic(InPlace(OnCell())))) with element type Float64"
     end
 
     @testset "Gridded" begin
         A = rand(20)
         A_x = collect(1.0:2.0:40.0)
         knots = (A_x,)
         itp = interpolate(knots, A, Gridded(Linear()))
-        @test summary(itp) == "20-element interpolate((::Array{Float64,1},), ::Array{Float64,1}, Gridded(Linear())) with element type Float64"
+        @test summary(itp) == "20-element interpolate((::Vector{Float64},), ::Vector{Float64}, Gridded(Linear())) with element type Float64" ||
+              summary(itp) == "20-element interpolate((::Array{Float64,1},), ::Array{Float64,1}, Gridded(Linear())) with element type Float64"
 
         A = rand(8,20)
         knots = ([x^2 for x = 1:8], [0.2y for y = 1:20])
         itp = interpolate(knots, A, Gridded(Linear()))
-        @test summary(itp) == "8×20 interpolate((::Array{Int64,1},::Array{Float64,1}), ::Array{Float64,2}, Gridded(Linear())) with element type Float64"
+        @test summary(itp) == "8×20 interpolate((::Vector{Int64},::Vector{Float64}), ::Matrix{Float64}, Gridded(Linear())) with element type Float64" ||
+              summary(itp) == "8×20 interpolate((::Array{Int64,1},::Array{Float64,1}), ::Array{Float64,2}, Gridded(Linear())) with element type Float64"
 
         itp = interpolate(knots, A, (Gridded(Linear()),Gridded(Constant())))
-        @test summary(itp) == "8×20 interpolate((::Array{Int64,1},::Array{Float64,1}), ::Array{Float64,2}, (Gridded(Linear()), Gridded(Constant()))) with element type Float64"
+        @test summary(itp) == "8×20 interpolate((::Vector{Int64},::Vector{Float64}), ::Matrix{Float64}, (Gridded(Linear()), Gridded(Constant()))) with element type Float64" ||
+              summary(itp) == "8×20 interpolate((::Array{Int64,1},::Array{Float64,1}), ::Array{Float64,2}, (Gridded(Linear()), Gridded(Constant()))) with element type Float64"
 
         # issue #260
         A = (1:4)/4
@@ -48,26 +57,33 @@ using Test
         show(io, MIME("text/plain"), itp)
         str1 = String(take!(io))
         str2 = "4-element interpolate((0.0:0.1:0.3,), ::Array{Float64,1}, Gridded(Linear())) with element type Float64:\n 0.25\n 0.5 \n 0.75\n 1.0"
-        @test filter(!isspace, str1) == filter(!isspace, str2)
+        str3 = "4-elementinterpolate((0.0:0.1:0.3,),::Vector{Float64},Gridded(Linear()))withelementtypeFloat64:\n 0.25 \n 0.5 \n 0.75\n 1.0"
+        @test filter(!isspace, str1) == filter(!isspace, str3) ||
+              filter(!isspace, str1) == filter(!isspace, str2)
         io2 = IOBuffer()
         show(io2, itp)
         str1 = String(take!(io2))
         str2 = "4-element interpolate((0.0:0.1:0.3,), ::Array{Float64,1}, Gridded(Linear())) with element type Float64:\n 0.25\n 0.5 \n 0.75\n 1.0"
-        @test filter(!isspace, str1) == filter(!isspace, str2)
+        str3 = "4-elementinterpolate((0.0:0.1:0.3,),::Vector{Float64},Gridded(Linear()))withelementtypeFloat64:\n 0.25\n 0.5\n 0.75\n 1.0"
+        @test filter(!isspace, str1) == filter(!isspace, str3) ||
+              filter(!isspace, str1) == filter(!isspace, str2)
     end
 
     @testset "scaled" begin
         itp = interpolate(1:1.0:10, BSpline(Linear()))
         sitp = scale(itp, -3:.5:1.5)
-        @test summary(sitp) == "10-element scale(interpolate(::Array{Float64,1}, BSpline(Linear())), (-3.0:0.5:1.5,)) with element type Float64"
+        @test summary(sitp) == "10-element scale(interpolate(::Vector{Float64}, BSpline(Linear())), (-3.0:0.5:1.5,)) with element type Float64" ||
+              summary(sitp) == "10-element scale(interpolate(::Array{Float64,1}, BSpline(Linear())), (-3.0:0.5:1.5,)) with element type Float64"
         io = IOBuffer()
         show(io, MIME("text/plain"), sitp)
         str = String(take!(io))
-        @test str == "10-element scale(interpolate(::Array{Float64,1}, BSpline(Linear())), (-3.0:0.5:1.5,)) with element type Float64:\n  1.0\n  2.0\n  3.0\n  4.0\n  5.0\n  6.0\n  7.0\n  8.0\n  9.0\n 10.0"
+        @test str == "10-element scale(interpolate(::Vector{Float64}, BSpline(Linear())), (-3.0:0.5:1.5,)) with element type Float64:\n  1.0\n  2.0\n  3.0\n  4.0\n  5.0\n  6.0\n  7.0\n  8.0\n  9.0\n 10.0" ||
+              str == "10-element scale(interpolate(::Array{Float64,1}, BSpline(Linear())), (-3.0:0.5:1.5,)) with element type Float64:\n  1.0\n  2.0\n  3.0\n  4.0\n  5.0\n  6.0\n  7.0\n  8.0\n  9.0\n 10.0"
         io2 = IOBuffer()
         show(io2, sitp)
         str2 = String(take!(io2))
-        @test str2 == "10-element scale(interpolate(::Array{Float64,1}, BSpline(Linear())), (-3.0:0.5:1.5,)) with element type Float64:\n  1.0\n  2.0\n  3.0\n  4.0\n  5.0\n  6.0\n  7.0\n  8.0\n  9.0\n 10.0"
+        @test str2 == "10-element scale(interpolate(::Vector{Float64}, BSpline(Linear())), (-3.0:0.5:1.5,)) with element type Float64:\n  1.0\n  2.0\n  3.0\n  4.0\n  5.0\n  6.0\n  7.0\n  8.0\n  9.0\n 10.0" ||
+              str2 == "10-element scale(interpolate(::Array{Float64,1}, BSpline(Linear())), (-3.0:0.5:1.5,)) with element type Float64:\n  1.0\n  2.0\n  3.0\n  4.0\n  5.0\n  6.0\n  7.0\n  8.0\n  9.0\n 10.0"
 
         gauss(phi, mu, sigma) = exp(-(phi-mu)^2 / (2sigma)^2)
         testfunction(x,y) = gauss(x, 0.5, 4) * gauss(y, -.5, 2)
@@ -77,29 +93,32 @@ using Test
         itp2 = interpolate(zs, BSpline(Quadratic(Flat(OnGrid()))))
         sitp2 = scale(itp2, xs, ys)
         teststring = "21×41 scale(interpolate(OffsetArray(::Array{Float64,2}, 0:22, 0:42), BSpline(Quadratic(Flat(OnGrid())))), (-5.0:0.5:5.0,$SPACE-4.0:0.2:4.0)) with element type Float64"
-        @test summary(sitp2) == teststring
+        teststring2 = "21×41 scale(interpolate(OffsetArray(::Matrix{Float64}, 0:22, 0:42), BSpline(Quadratic(Flat(OnGrid())))), (-5.0:0.5:5.0,$SPACE-4.0:0.2:4.0)) with element type Float64"
+        @test summary(sitp2) == teststring2 ||
+              summary(sitp2) == teststring
         io3 = IOBuffer()
         show(io3, sitp2)
         str3 = String(take!(io3))
-        @test occursin(teststring, str3)
+        @test occursin(teststring2, str3) || occursin(teststring, str3)
     end
 
     @testset "Monotonic" begin
         A_x = collect(1.0:2.0:40.0)
         A = map(x->x^2, A_x)
         itp = interpolate(A_x, A, FritschButlandMonotonicInterpolation())
         teststring = "20-element interpolate(::Array{Float64,1}, ::Array{Float64,1}, FritschButlandMonotonicInterpolation()) with element type Float64"
-        @test summary(itp) == teststring
+        teststring2 = "20-element interpolate(::Vector{Float64}, ::Vector{Float64}, FritschButlandMonotonicInterpolation()) with element type Float64"
+        @test summary(itp) == teststring2 || summary(itp) == teststring
 
         io = IOBuffer()
         show(io, itp)
         str = String(take!(io))
-        @test occursin(teststring, str)
+        @test occursin(teststring2, str) || occursin(teststring, str)
 
         io2 = IOBuffer()
         show(io2, MIME("text/plain"), itp)
         str = String(take!(io2))
-        @test occursin(teststring, str)
+        @test occursin(teststring2, str) || occursin(teststring, str)
     end
 
     @testset "Extrapolation" begin
@@ -108,19 +127,21 @@ using Test
         itpg = interpolate(A, BSpline(Linear()))
         etpg = extrapolate(itpg, Flat())
         teststring = "8×20 extrapolate(interpolate(::Array{Float64,2}, BSpline(Linear())), Flat()) with element type Float64"
-        @test summary(etpg) == teststring
+        teststring16 = "8×20 extrapolate(interpolate(::Matrix{Float64}, BSpline(Linear())), Flat()) with element type Float64"
+        @test summary(etpg) == teststring16 || summary(etpg) == teststring
         io = IOBuffer()
         show(io, etpg)
         str = String(take!(io))
-        @test occursin(teststring, str)
+        @test occursin(teststring16, str) || occursin(teststring, str)
 
         etpf = extrapolate(itpg, NaN)
         teststring2 = "8×20 extrapolate(interpolate(::Array{Float64,2}, BSpline(Linear())), NaN) with element type Float64"
-        @test summary(etpf) == teststring2
+        teststring16 = "8×20 extrapolate(interpolate(::Matrix{Float64}, BSpline(Linear())), NaN) with element type Float64"
+        @test summary(etpf) == teststring16 || summary(etpf) == teststring2
         io2 = IOBuffer()
         show(io2, etpf)
         str2 = String(take!(io2))
-        @test occursin(teststring2, str2)
+        @test occursin(teststring16, str2) || occursin(teststring2, str2)
     end
 
     @testset "Combinations" begin
@@ -138,6 +159,7 @@ using Test
         io = IOBuffer()
         show(io, MIME("text/plain"), itp)
         str = String(take!(io))
-        @test str == "3×3×3 scale(interpolate(OffsetArray(::Array{Float64,3}, 0:4, 0:4, 0:4), BSpline(Cubic(Free(OnGrid())))), (2:4, 2:4, 2:4)) with element type Float64:\n[:, :, 1] =\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n\n[:, :, 2] =\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n\n[:, :, 3] =\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n 0.0  0.0  0.0"
+        @test str == "3×3×3 scale(interpolate(OffsetArray(::Array{Float64, 3}, 0:4, 0:4, 0:4), BSpline(Cubic(Free(OnGrid())))), (2:4, 2:4, 2:4)) with element type Float64:\n[:, :, 1] =\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n\n[:, :, 2] =\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n\n[:, :, 3] =\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n 0.0  0.0  0.0" ||
+              str == "3×3×3 scale(interpolate(OffsetArray(::Array{Float64,3}, 0:4, 0:4, 0:4), BSpline(Cubic(Free(OnGrid())))), (2:4, 2:4, 2:4)) with element type Float64:\n[:, :, 1] =\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n\n[:, :, 2] =\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n\n[:, :, 3] =\n 0.0  0.0  0.0\n 0.0  0.0  0.0\n 0.0  0.0  0.0"
     end
 end # testset
