fix v0.6 warnings

Author: jw3126

.travis.yml

@@ -1,8 +1,8 @@
 language: julia
 sudo: false
 julia:
-    - 0.4
     - 0.5
+    - release
     - nightly
 matrix:
     - allow_failures:

test/b-splines/cubic.jl

@@ -22,7 +22,7 @@ for (constructor, copier) in ((interpolate, identity), (interpolate!, copy))
 
             # test that inner region is close to data
             for x in 3.1:.2:8.1
-                @test_approx_eq_eps f(x) itp1[x] abs(.1*f(x))
+                @test ≈(f(x),itp1[x],atol=abs(0.1 * f(x)))
             end
 
             # test that we can evaluate close to, and at, boundaries
@@ -45,7 +45,7 @@ for (constructor, copier) in ((interpolate, identity), (interpolate!, copy))
         @test @inferred(size(itp2)) == size(A2)
 
         for x in 3.1:.2:xmax2-3, y in 3.1:2:ymax2-3
-            @test_approx_eq_eps f2(x,y) itp2[x,y] abs(.1*f2(x,y))
+            @test ≈(f2(x,y),itp2[x,y],atol=abs(0.1 * f2(x,y)))
         end
     end
 end
@@ -60,7 +60,7 @@ ix = 1:15
 f(x) = cos((x-1)*2pi/(length(ix)-1))
 g(x) = -2pi/14 * sin((x-1)*2pi/(length(ix)-1))
 
-A = f(ix)
+A = map(f, ix)
 
 for (constructor, copier) in ((interpolate, identity), (interpolate!, copy))
 
@@ -69,16 +69,16 @@ for (constructor, copier) in ((interpolate, identity), (interpolate!, copy))
         itp = constructor(copier(A), BSpline(Cubic(BC())), GT())
         # test that inner region is close to data
         for x in linspace(ix[5],ix[end-4],100)
-            @test_approx_eq_eps g(x) gradient(itp,x)[1] cbrt(cbrt(eps(g(x))))
+            @test ≈(g(x),(gradient(itp,x))[1],atol=cbrt(cbrt(eps(g(x)))))
         end
     end
 end
 itp_flat_g = interpolate(A, BSpline(Cubic(Flat())), OnGrid())
-@test_approx_eq_eps gradient(itp_flat_g, 1)[1] 0 eps()
-@test_approx_eq_eps gradient(itp_flat_g, ix[end])[1] 0 eps()
+@test ≈((gradient(itp_flat_g,1))[1],0,atol=eps())
+@test ≈((gradient(itp_flat_g,ix[end]))[1],0,atol=eps())
 
 itp_flat_c = interpolate(A, BSpline(Cubic(Flat())), OnCell())
-@test_approx_eq_eps gradient(itp_flat_c, .5)[1] 0 eps()
-@test_approx_eq_eps gradient(itp_flat_c, ix[end]+.5)[1] 0 eps()
+@test ≈((gradient(itp_flat_c,0.5))[1],0,atol=eps())
+@test ≈((gradient(itp_flat_c,ix[end] + 0.5))[1],0,atol=eps())
 
-end
+end

test/b-splines/linear.jl

@@ -19,14 +19,14 @@ for (constructor, copier) in ((interpolate, _->_), (interpolate!, copy))
 
     # Just interpolation
     for x in 1:.2:xmax
-        @test_approx_eq_eps f(x) itp1c[x] abs(.1*f(x))
+        @test ≈(f(x),itp1c[x],atol=abs(0.1 * f(x)))
     end
 
     # 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)
-    @test_approx_eq_eps itp1r[23//10] fr(23//10) abs(.1*fr(23//10))
+    @test ≈(itp1r[23 // 10],fr(23 // 10),atol=abs(0.1 * fr(23 // 10)))
     @test typeof(itp1r[23//10]) == Rational{Int}
     @test eltype(itp1r) == Rational{Int}
 
@@ -35,7 +35,7 @@ for (constructor, copier) in ((interpolate, _->_), (interpolate!, copy))
     @test @inferred(size(itp2)) == size(A2)
 
     for x in 2.1:.2:xmax-1, y in 1.9:.2:ymax-.9
-        @test_approx_eq_eps f(x,y) itp2[x,y] abs(.25*f(x,y))
+        @test ≈(f(x,y),itp2[x,y],atol=abs(0.25 * f(x,y)))
     end
 end
 

test/b-splines/mixed.jl

@@ -13,14 +13,14 @@ for (constructor, copier) in ((interpolate, x->x), (interpolate!, copy))
         @test @inferred(size(itp_b)) == size(A2)
 
         for j = 2:N-1, i = 2:N-1
-            @test_approx_eq_eps itp_a[i,j] A2[i,j] sqrt(eps(A2[i,j]))
-            @test_approx_eq_eps itp_b[i,j] A2[i,j] sqrt(eps(A2[i,j]))
+            @test ≈(itp_a[i,j],A2[i,j],atol=sqrt(eps(A2[i,j])))
+            @test ≈(itp_b[i,j],A2[i,j],atol=sqrt(eps(A2[i,j])))
         end
 
         for i = 1:10
             dx, dy = rand(), rand()
-            @test_approx_eq itp_a[2+dx,2] (1-dx)*A2[2,2]+dx*A2[3,2]
-            @test_approx_eq itp_b[2,2+dy] (1-dy)*A2[2,2]+dy*A2[2,3]
+            @test itp_a[2 + dx,2] ≈ (1 - dx) * A2[2,2] + dx * A2[3,2]
+            @test itp_b[2,2 + dy] ≈ (1 - dy) * A2[2,2] + dy * A2[2,3]
         end
     end
 end
@@ -47,14 +47,14 @@ for (constructor, copier) in ((interpolate, x->x), (interpolate!, copyshared))
         @test @inferred(size(itp_b)) == size(A2)
 
         for j = 2:N-1, i = 2:N-1
-            @test_approx_eq_eps itp_a[i,j] A2[i,j] sqrt(eps(A2[i,j]))
-            @test_approx_eq_eps itp_b[i,j] A2[i,j] sqrt(eps(A2[i,j]))
+            @test ≈(itp_a[i,j],A2[i,j],atol=sqrt(eps(A2[i,j])))
+            @test ≈(itp_b[i,j],A2[i,j],atol=sqrt(eps(A2[i,j])))
         end
 
         for i = 1:10
             dx, dy = rand(), rand()
-            @test_approx_eq itp_a[2+dx,2] (1-dx)*A2[2,2]+dx*A2[3,2]
-            @test_approx_eq itp_b[2,2+dy] (1-dy)*A2[2,2]+dy*A2[2,3]
+            @test itp_a[2 + dx,2] ≈ (1 - dx) * A2[2,2] + dx * A2[3,2]
+            @test itp_b[2,2 + dy] ≈ (1 - dy) * A2[2,2] + dy * A2[2,3]
         end
     end
 end

test/b-splines/quadratic.jl

@@ -12,7 +12,7 @@ for (constructor, copier) in ((interpolate, x->x), (interpolate!, copy))
 
         # test that inner region is close to data
         for x in 3.1:.2:8.1
-            @test_approx_eq_eps f(x) itp1[x] abs(.1*f(x))
+            @test ≈(f(x),itp1[x],atol=abs(0.1 * f(x)))
         end
 
         # test that we can evaluate close to, and at, boundaries
@@ -41,7 +41,7 @@ for (constructor, copier) in ((interpolate, x->x), (interpolate!, copy))
         @test @inferred(size(itp2)) == size(A)
 
         for x in 3.1:.2:xmax-3, y in 3.1:2:ymax-3
-            @test_approx_eq_eps f(x,y) itp2[x,y] abs(.1*f(x,y))
+            @test ≈(f(x,y),itp2[x,y],atol=abs(0.1 * f(x,y)))
         end
     end
 end
@@ -52,15 +52,15 @@ let
     A = Float64[f(x) for x in 1:xmax]
     itp1 = interpolate!(copy(A), BSpline(Quadratic(InPlace())), OnCell())
     for i = 1:xmax
-        @test_approx_eq itp1[i] A[i]
+        @test itp1[i] ≈ A[i]
     end
 
     f(x,y) = sin(x/10)*cos(y/6)
     xmax, ymax = 30,10
     A = Float64[f(x,y) for x in 1:xmax, y in 1:ymax]
     itp2 = interpolate!(copy(A), BSpline(Quadratic(InPlace())), OnCell())
     for j = 1:ymax, i = 1:xmax
-        @test_approx_eq itp2[i,j] A[i,j]
+        @test itp2[i,j] ≈ A[i,j]
     end
 end
 

test/extrapolation/runtests.jl

@@ -19,23 +19,23 @@ etpf = @inferred(extrapolate(itpg, NaN))
 @test @inferred(size(etpf)) == (xmax,)
 @test isnan(@inferred(getindex(etpf, -2.5)))
 @test isnan(etpf[0.999])
-@test_approx_eq @inferred(getindex(etpf, 1)) f(1)
-@test_approx_eq etpf[10] f(10)
+@test @inferred(getindex(etpf,1)) ≈ f(1)
+@test etpf[10] ≈ f(10)
 @test isnan(@inferred(getindex(etpf,10.001)))
 
 @test etpf[2.5,1] == etpf[2.5]   # for show method
 @test_throws BoundsError etpf[2.5,2]
 @test_throws ErrorException etpf[2.5,2,1]  # this will probably become a BoundsError someday
 
-@test isa(@inferred(getindex(etpf, dual(-2.5,1))), Dual)
+@test_broken isa(@inferred(getindex(etpf, dual(-2.5,1))), Dual)
 
 etpl = extrapolate(itpg, Linear())
 k_lo = A[2] - A[1]
 x_lo = -3.2
-@test_approx_eq etpl[x_lo] A[1]+k_lo*(x_lo-1)
+@test etpl[x_lo] ≈ A[1] + k_lo * (x_lo - 1)
 k_hi = A[end] - A[end-1]
 x_hi = xmax + 5.7
-@test_approx_eq etpl[x_hi] A[end]+k_hi*(x_hi-xmax)
+@test etpl[x_hi] ≈ A[end] + k_hi * (x_hi - xmax)
 
 
 xmax, ymax = 8,8
@@ -44,17 +44,17 @@ g(x, y) = (x^2 + 3x - 8) * (-2y^2 + y + 1)
 itp2g = interpolate(Float64[g(x,y) for x in 1:xmax, y in 1:ymax], (BSpline(Quadratic(Free())), BSpline(Linear())), OnGrid())
 etp2g = extrapolate(itp2g, (Linear(), Flat()))
 
-@test_approx_eq @inferred(getindex(etp2g, -.5, 4)) itp2g[1,4]-1.5*epsilon(etp2g[dual(1,1),4])
-@test_approx_eq @inferred(getindex(etp2g, 5, 100)) itp2g[5,ymax]
+@test @inferred(getindex(etp2g,-0.5,4)) ≈ itp2g[1,4] - 1.5 * epsilon(etp2g[dual(1,1),4])
+@test @inferred(getindex(etp2g,5,100)) ≈ itp2g[5,ymax]
 
 etp2ud = extrapolate(itp2g, ((Linear(), Flat()), Flat()))
-@test_approx_eq @inferred(getindex(etp2ud, -.5, 4)) itp2g[1,4] - 1.5*epsilon(etp2g[dual(1,1),4])
+@test @inferred(getindex(etp2ud,-0.5,4)) ≈ itp2g[1,4] - 1.5 * epsilon(etp2g[dual(1,1),4])
 @test @inferred(getindex(etp2ud, 5, -4)) == etp2ud[5,1]
 @test @inferred(getindex(etp2ud, 100, 4)) == etp2ud[8,4]
 @test @inferred(getindex(etp2ud, -.5, 100)) == itp2g[1,8] - 1.5 * epsilon(etp2g[dual(1,1),8])
 
 etp2ll = extrapolate(itp2g, Linear())
-@test_approx_eq @inferred(getindex(etp2ll, -.5, 100)) itp2g[1,8]-1.5*epsilon(etp2ll[dual(1,1),8]) + (100-8) * epsilon(etp2ll[1,dual(8,1)])
+@test @inferred(getindex(etp2ll,-0.5,100)) ≈ (itp2g[1,8] - 1.5 * epsilon(etp2ll[dual(1,1),8])) + (100 - 8) * epsilon(etp2ll[1,dual(8,1)])
 
 # Allow element types that don't support conversion to Int (#87):
 etp87g = extrapolate(interpolate([1.0im, 2.0im, 3.0im], BSpline(Linear()), OnGrid()), 0.0im)
@@ -78,4 +78,4 @@ etp100g = extrapolate(interpolate(([10;20],),[100;110], Gridded(Linear())), Flat
 @test @inferred(getindex(etp100g, 25)) == 110
 end
 
-include("type-stability.jl")
+include("type-stability.jl")

test/extrapolation/type-stability.jl

@@ -50,4 +50,4 @@ for (etp2,E) in map(E -> (extrapolate(itp2, E()), E), schemes),
     @inferred(getindex(etp2, x, y))
 end
 
-end
+end

test/gradient.jl

@@ -25,16 +25,16 @@ itp2 = interpolate((1:nx-1,), Float64[f1(x) for x in 1:nx-1],
             Gridded(Linear()))
 for itp in (itp1, itp2)
     for x in 2.5:nx-1.5
-        @test_approx_eq_eps g1(x) gradient(itp, x)[1] abs(.1*g1(x))
-        @test_approx_eq_eps g1(x) gradient!(g, itp, x)[1] abs(.1*g1(x))
-        @test_approx_eq_eps g1(x) g[1] abs(.1*g1(x))
+        @test ≈(g1(x),(gradient(itp,x))[1],atol=abs(0.1 * g1(x)))
+        @test ≈(g1(x),(gradient!(g,itp,x))[1],atol=abs(0.1 * g1(x)))
+        @test ≈(g1(x),g[1],atol=abs(0.1 * g1(x)))
     end
 
     for i = 1:10
         x = rand()*(nx-2)+1.5
         gtmp = gradient(itp, x)[1]
         xd = dual(x, 1)
-        @test_approx_eq epsilon(itp[xd]) gtmp
+        @test epsilon(itp[xd]) ≈ gtmp
     end
 end
 
@@ -44,25 +44,25 @@ itp_grid = interpolate(knots, Float64[f1(x) for x in knots[1]],
                        Gridded(Linear()))
 
 for x in 1.5:0.5:nx-1.5
-    @test_approx_eq_eps g1(x) gradient(itp_grid, x)[1] abs(.5*g1(x))
-    @test_approx_eq_eps g1(x) gradient!(g, itp_grid, x)[1] abs(.5*g1(x))
-    @test_approx_eq_eps g1(x) g[1] abs(.5*g1(x))
+    @test ≈(g1(x),(gradient(itp_grid,x))[1],atol=abs(0.5 * g1(x)))
+    @test ≈(g1(x),(gradient!(g,itp_grid,x))[1],atol=abs(0.5 * g1(x)))
+    @test ≈(g1(x),g[1],atol=abs(0.5 * g1(x)))
 end
 
 # Since Quadratic is OnCell in the domain, check gradients at grid points
 itp1 = interpolate(Float64[f1(x) for x in 1:nx-1],
             BSpline(Quadratic(Periodic())), OnCell())
 for x in 2:nx-1
-    @test_approx_eq_eps g1(x) gradient(itp1, x)[1] abs(.05*g1(x))
-    @test_approx_eq_eps g1(x) gradient!(g, itp1, x)[1] abs(.05*g1(x))
-    @test_approx_eq_eps g1(x) g[1] abs(.1*g1(x))
+    @test ≈(g1(x),(gradient(itp1,x))[1],atol=abs(0.05 * g1(x)))
+    @test ≈(g1(x),(gradient!(g,itp1,x))[1],atol=abs(0.05 * g1(x)))
+    @test ≈(g1(x),g[1],atol=abs(0.1 * g1(x)))
 end
 
 for i = 1:10
     x = rand()*(nx-2)+1.5
     gtmp = gradient(itp1, x)[1]
     xd = dual(x, 1)
-    @test_approx_eq epsilon(itp1[xd]) gtmp
+    @test epsilon(itp1[xd]) ≈ gtmp
 end
 
 # For a quadratic function and quadratic interpolation, we expect an
@@ -78,33 +78,33 @@ y = qfunc(xg)
 
 iq = interpolate(y, BSpline(Quadratic(Free())), OnCell())
 x = 1.8
-@test_approx_eq iq[x] qfunc(x)
-@test_approx_eq gradient(iq, x)[1] dqfunc(x)
+@test iq[x] ≈ qfunc(x)
+@test (gradient(iq,x))[1] ≈ dqfunc(x)
 
 # 2d (biquadratic)
 p = [(x-1.75)^2 for x = 1:7]
 A = p*p'
 iq = interpolate(A, BSpline(Quadratic(Free())), OnCell())
-@test_approx_eq iq[4,4] (4-1.75)^4
-@test_approx_eq iq[4,3] (4-1.75)^2*(3-1.75)^2
+@test iq[4,4] ≈ (4 - 1.75) ^ 4
+@test iq[4,3] ≈ (4 - 1.75) ^ 2 * (3 - 1.75) ^ 2
 g = gradient(iq, 4, 3)
-@test_approx_eq g[1] 2*(4-1.75)*(3-1.75)^2
-@test_approx_eq g[2] 2*(4-1.75)^2*(3-1.75)
+@test g[1] ≈ 2 * (4 - 1.75) * (3 - 1.75) ^ 2
+@test g[2] ≈ 2 * (4 - 1.75) ^ 2 * (3 - 1.75)
 
 iq = interpolate!(copy(A), BSpline(Quadratic(InPlace())), OnCell())
-@test_approx_eq iq[4,4] (4-1.75)^4
-@test_approx_eq iq[4,3] (4-1.75)^2*(3-1.75)^2
+@test iq[4,4] ≈ (4 - 1.75) ^ 4
+@test iq[4,3] ≈ (4 - 1.75) ^ 2 * (3 - 1.75) ^ 2
 g = gradient(iq, 4, 3)
-@test_approx_eq_eps g[1] 2*(4-1.75)*(3-1.75)^2 0.03
-@test_approx_eq_eps g[2] 2*(4-1.75)^2*(3-1.75) 0.2
+@test ≈(g[1],2 * (4 - 1.75) * (3 - 1.75) ^ 2,atol=0.03)
+@test ≈(g[2],2 * (4 - 1.75) ^ 2 * (3 - 1.75),atol=0.2)
 
 # InPlaceQ is exact for an underlying quadratic
 iq = interpolate!(copy(A), BSpline(Quadratic(InPlaceQ())), OnCell())
-@test_approx_eq iq[4,4] (4-1.75)^4
-@test_approx_eq iq[4,3] (4-1.75)^2*(3-1.75)^2
+@test iq[4,4] ≈ (4 - 1.75) ^ 4
+@test iq[4,3] ≈ (4 - 1.75) ^ 2 * (3 - 1.75) ^ 2
 g = gradient(iq, 4, 3)
-@test_approx_eq g[1] 2*(4-1.75)*(3-1.75)^2
-@test_approx_eq g[2] 2*(4-1.75)^2*(3-1.75)
+@test g[1] ≈ 2 * (4 - 1.75) * (3 - 1.75) ^ 2
+@test g[2] ≈ 2 * (4 - 1.75) ^ 2 * (3 - 1.75)
 
 A2 = rand(Float64, nx, nx) * 100
 for BC in (Flat,Line,Free,Periodic,Reflect,Natural), GT in (OnGrid, OnCell)
@@ -120,19 +120,19 @@ for BC in (Flat,Line,Free,Periodic,Reflect,Natural), GT in (OnGrid, OnCell)
         yd = dual(y, 1)
         gtmp = gradient(itp_a, x, y)
         @test length(gtmp) == 2
-        @test_approx_eq epsilon(itp_a[xd, y]) gtmp[1]
-        @test_approx_eq epsilon(itp_a[x, yd]) gtmp[2]
+        @test epsilon(itp_a[xd,y]) ≈ gtmp[1]
+        @test epsilon(itp_a[x,yd]) ≈ gtmp[2]
         gtmp = gradient(itp_b, x, y)
         @test length(gtmp) == 2
-        @test_approx_eq epsilon(itp_b[xd, y]) gtmp[1]
-        @test_approx_eq epsilon(itp_b[x, yd]) gtmp[2]
+        @test epsilon(itp_b[xd,y]) ≈ gtmp[1]
+        @test epsilon(itp_b[x,yd]) ≈ gtmp[2]
         ix, iy = round(Int, x), round(Int, y)
         gtmp = gradient(itp_c, ix, y)
         @test length(gtmp) == 1
-        @test_approx_eq epsilon(itp_c[ix, yd]) gtmp[1]
+        @test epsilon(itp_c[ix,yd]) ≈ gtmp[1]
         gtmp = gradient(itp_d, x, iy)
         @test length(gtmp) == 1
-        @test_approx_eq epsilon(itp_d[xd, iy]) gtmp[1]
+        @test epsilon(itp_d[xd,iy]) ≈ gtmp[1]
     end
 end
 

test/grid.jl

@@ -10,7 +10,7 @@ for it in (Constant(OnCell()), Linear(OnGrid()), Quadratic(Free(),OnCell()))
         itp = Interpolation(A, it, eb)
         for i = 1:size(A,1)
             for j = 1:size(A,2)
-                @test_approx_eq_eps itp[i,j] A[i,j] EPS
+                @test ≈(itp[i,j],A[i,j],atol=EPS)
             end
         end
         # v = itp[1:size(A,1), 1:size(A,2)]
@@ -23,7 +23,7 @@ for it in (Constant(OnCell()), Linear(OnGrid()), Quadratic(Free(),OnCell()))
     for eb in (ExtrapNaN(), ExtrapError())
         itp = Interpolation(A, it, eb)
         for k = 1:size(A,3), j = 1:size(A,2), i = 1:size(A,1)
-            @test_approx_eq_eps itp[i,j,k] A[i,j,k] EPS
+            @test ≈(itp[i,j,k],A[i,j,k],atol=EPS)
         end
         # v = itp[1:size(A,1), 1:size(A,2), 1:size(A,3)]
         # @assert all(abs(v - A) .< EPS)
@@ -34,7 +34,7 @@ for it in (Constant(OnCell()), Linear(OnGrid()), Quadratic(Free(),OnCell()))
     for eb in (ExtrapNaN(), ExtrapError())
         itp = Interpolation(A, it, eb)
         for i = 1:size(A,1), j = 1:size(A,2), k = 1:size(A,3), l = 1:size(A,4)
-            @test_approx_eq_eps itp[i,j,k,l] A[i,j,k,l] EPS
+            @test ≈(itp[i,j,k,l],A[i,j,k,l],atol=EPS)
         end
         # v = itp[1:size(A,1), 1:size(A,2), 1:size(A,3), 1:size(A,4)]
         # @assert all(abs(v - A) .< EPS)