Merge pull request #135 from jw3126/fix0.6

Fix0.6

Author: timholy

.travis.yml

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

perf/plot_shootout.jl

@@ -36,4 +36,4 @@ pGc = plot(dfGconstr, xgroup="dim", ygroup="ord", x="name", y="t", Geom.subplot_
 draw(PNG("constructionG.png", plotsize...), pGc)
 
 pGr = plot(dfGeval, xgroup="dim", ygroup="ord", x="name", y="rate", Geom.subplot_grid(Geom.point), Scale.y_sqrt, Guide.ylabel("Throughput (pts/s) by order"))
-draw(PNG("rateG.png", plotsize...), pGr)
+draw(PNG("rateG.png", plotsize...), pGr)

perf/run_shootout.jl

@@ -77,7 +77,7 @@ stuff!(x, index::CartesianIndex{4}) = (x[1] = index[1]; x[2] = index[2]; x[3] =
 
 function evaluate_grid(grid::GridInterpolations.RectangleGrid, A)
     T = eltype(A)
-    x = Array(eltype(T), ndims(A))  # in case T is RGB{Float32}
+    x = Array{eltype(T)}( ndims(A))  # in case T is RGB{Float32}
     s = zero(T) + zero(T)
     vA = vec(A)
     for I in iterrange(A)
@@ -92,10 +92,10 @@ ax_constr(A) = ApproXD.Lininterp(A, Vector{Float64}[make_knots(A)...])
 
 function evaluate_grid(grid::ApproXD.Lininterp, A)
     T = eltype(A)
-    x = Array(eltype(T), ndims(A))  # in case T is RGB{Float32}
+    x = Array{eltype(T)}( ndims(A))  # in case T is RGB{Float32}
     s = zero(T) + zero(T)
     vA = vec(A)
-    result = Array(T,1)
+    result = Array{T}(1)
     which = [1]
     for I in iterrange(A)
         stuff!(x, I)
@@ -181,4 +181,4 @@ for ieltype = 1:length(eltypes)
             end
         end
     end
-end
+end

src/Interpolations-old.jl

@@ -222,7 +222,7 @@ stagedfunction gradient!{T,N,TCoefs,TOut,IT,EB}(g::Vector{TOut}, itp::Interpolat
     end
 end
 
-gradient{T,N}(itp::Interpolation{T,N}, x...) = gradient!(Array(T,N), itp, x...)
+gradient{T,N}(itp::Interpolation{T,N}, x...) = gradient!(Array{T}(N), itp, x...)
 
 # This creates prefilter specializations for all interpolation types that need them
 stagedfunction prefilter{TWeights,TCoefs,N,IT<:Quadratic}(::Type{TWeights}, A::Array{TCoefs,N}, it::IT)
@@ -258,4 +258,4 @@ end
 
 nindexes(N::Int) = N == 1 ? "1 index" : "$N indexes"
 
-end # module
+end # module

src/Interpolations.jl

@@ -35,7 +35,11 @@ export
 using Compat
 using WoodburyMatrices, Ratios, AxisAlgorithms
 
-import Base: convert, size, getindex, gradient, scale, promote_rule, ndims, eltype
+import Base: convert, size, getindex, gradient, promote_rule, ndims, eltype
+
+# Julia v0.5 compatibility
+if isdefined(:scaling) import Base.scaling end
+if isdefined(:scale) import Base.scale end
 
 abstract Flag
 abstract InterpolationType <: Flag

src/b-splines/b-splines.jl

@@ -73,10 +73,15 @@ function interpolate!{IT<:DimSpec{BSpline},GT<:DimSpec{GridType}}(A::AbstractArr
     interpolate!(tweight(A), A, it, gt)
 end
 
+offsetsym(off, d) = off == -1 ? Symbol("ixm_", d) :
+                    off ==  0 ? Symbol("ix_", d) :
+                    off ==  1 ? Symbol("ixp_", d) :
+                    off ==  2 ? Symbol("ixpp_", d) : error("offset $off not recognized")
+
 include("constant.jl")
 include("linear.jl")
 include("quadratic.jl")
 include("cubic.jl")
 include("indexing.jl")
 include("prefiltering.jl")
-include("../filter1d.jl")
+include("../filter1d.jl")

src/b-splines/constant.jl

@@ -50,4 +50,4 @@ function index_gen{IT<:DimSpec{BSpline}}(::Type{BSpline{Constant}}, ::Type{IT},
         indices = [offsetsym(offsets[d], d) for d = 1:N]
         return :(itp.coefs[$(indices...)])
     end
-end
+end

src/b-splines/cubic.jl

@@ -316,4 +316,4 @@ function prefiltering_system{T,TC,GT<:GridType}(::Type{T}, ::Type{TC}, n::Int,
                                   )
 
     Woodbury(lufact!(Tridiagonal(dl, d, du), Val{false}), specs...), zeros(TC, n)
-end
+end

src/b-splines/indexing.jl

@@ -1,4 +1,5 @@
 using Base.Cartesian
+using DualNumbers
 
 import Base.getindex
 
@@ -54,7 +55,7 @@ function gradient_impl{T,N,TCoefs,IT<:DimSpec{BSpline},GT<:DimSpec{GridType},Pad
     # For each component of the gradient, alternately calculate
     # coefficients and set component
     n = count_interp_dims(IT, N)
-    exs = Array(Expr, 2n)
+    exs = Array{Expr, 1}(2n)
     cntr = 0
     for d = 1:N
         if count_interp_dims(iextract(IT, d), 1) > 0
@@ -79,14 +80,13 @@ function gradient_impl{T,N,TCoefs,IT<:DimSpec{BSpline},GT<:DimSpec{GridType},Pad
     end
 end
 
-function getindex_return_type{T,N,TCoefs,IT<:DimSpec{BSpline},GT<:DimSpec{GridType},Pad}(::Type{BSplineInterpolation{T,N,TCoefs,IT,GT,Pad}}, argtypes)
-    Tret = eltype(TCoefs)
-    for a in argtypes
-        Tret = Base.promote_op(@functorize(*), Tret, a) # the macro is used to support julia 0.4
-    end
-    Tret
-end
+# there is a Heisenbug, when Base.promote_op is inlined into getindex_return_type
+# thats why we use this @noinline fence
+@noinline _promote_mul(a,b) = Base.promote_op(@functorize(*), a, b)
 
+@noinline function getindex_return_type{T,N,TCoefs,IT<:DimSpec{BSpline},GT<:DimSpec{GridType},Pad}(::Type{BSplineInterpolation{T,N,TCoefs,IT,GT,Pad}}, argtypes)
+    reduce(_promote_mul, eltype(TCoefs), argtypes)
+end
 
 @generated function gradient!{T,N}(g::AbstractVector, itp::BSplineInterpolation{T,N}, xs::Number...)
     length(xs) == N || error("Can only be called with $N indexes")
@@ -104,7 +104,7 @@ for R in [:Real, :Any]
         n = count_interp_dims(itp, N)
         Tg = promote_type(T, [x <: AbstractArray ? eltype(x) : x for x in xs]...)
         xargs = [:(xs[$d]) for d in 1:length(xs)]
-        :(gradient!(Array($Tg,$n), itp, $(xargs...)))
+        :(gradient!(Array{$Tg, 1}($n), itp, $(xargs...)))
     end
 end
 
@@ -153,12 +153,7 @@ end
     n = count_interp_dims(itp,N)
     TH = promote_type(T, [x <: AbstractArray ? eltype(x) : x for x in xs]...)
     xargs = [:(xs[$d]) for d in 1:length(xs)]
-    :(hessian!(Array($TH,$n,$n), itp, $(xargs...)))
+    :(hessian!(Array{TH, 2}($n,$n), itp, $(xargs...)))
 end
 
 hessian1{T}(itp::AbstractInterpolation{T,1}, x) = hessian(itp, x)[1,1]
-
-offsetsym(off, d) = off == -1 ? Symbol("ixm_", d) :
-                    off ==  0 ? Symbol("ix_", d) :
-                    off ==  1 ? Symbol("ixp_", d) :
-                    off ==  2 ? Symbol("ixpp_", d) : error("offset $off not recognized")

src/b-splines/linear.jl

@@ -100,4 +100,4 @@ function index_gen{IT<:DimSpec{BSpline}}(::Type{BSpline{Linear}}, ::Type{IT}, N:
         indices = [offsetsym(offsets[d], d) for d = 1:N]
         return :(itp.coefs[$(indices...)])
     end
-end
+end