Use zero and oneunit in place of one

In Julia 0.6, a distinction is made between one(T) (multiplicative identity) and oneunit(T) ("1" of type T). In essentially every place we mean oneunit rather than one. However, packages like StaticArrays (for multivalued interpolation) don't define either, but `zero` will work for us.

Also deletes Interpolations-old.jl, which I don't think has a purpose.

Author: timholy

src/Interpolations-old.jl

@@ -43,6 +43,9 @@ import Base: convert, size, indices, getindex, gradient, promote_rule,
 # Julia v0.5 compatibility
 if isdefined(:scaling) import Base.scaling end
 if isdefined(:scale) import Base.scale end
+if !isdefined(Base, :oneunit)
+    const oneunit = one
+end
 
 @compat abstract type Flag end
 @compat abstract type InterpolationType <: Flag end

src/Interpolations.jl

@@ -21,11 +21,11 @@ function BSplineInterpolation{N,Tel,TWeights<:Real,IT<:DimSpec{BSpline},GT<:DimS
     isleaftype(IT) || error("The b-spline type must be a leaf type (was $IT)")
     isleaftype(typeof(A)) || warn("For performance reasons, consider using an array of a concrete type (typeof(A) == $(typeof(A)))")
 
-    c = one(TWeights)
+    c = zero(TWeights)
     for _ in 2:N
         c *= c
     end
-    T = typeof(c * one(Tel))
+    T = typeof(c * zero(Tel))
 
     BSplineInterpolation{T,N,typeof(A),IT,GT,pad}(A)
 end

src/b-splines/b-splines.jl

@@ -187,11 +187,11 @@ Applying this condition yields
 function prefiltering_system{T,TC}(::Type{T}, ::Type{TC}, n::Int,
                                    ::Type{Cubic{Flat}}, ::Type{OnGrid})
     dl, d, du = inner_system_diags(T, n, Cubic{Flat})
-    d[1] = d[end] = -one(T)
+    d[1] = d[end] = -oneunit(T)
     du[1] = dl[end] = zero(T)
 
     # Now Woodbury correction to set `[1, 3], [n, n-2] ==> 1`
-    specs = WoodburyMatrices.sparse_factors(T, n, (1, 3, one(T)), (n, n-2, one(T)))
+    specs = WoodburyMatrices.sparse_factors(T, n, (1, 3, oneunit(T)), (n, n-2, oneunit(T)))
 
     Woodbury(lufact!(Tridiagonal(dl, d, du), Val{false}), specs...), zeros(TC, n)
 end
@@ -222,8 +222,8 @@ function prefiltering_system{T,TC}(::Type{T}, ::Type{TC}, n::Int,
     specs = WoodburyMatrices.sparse_factors(T, n,
                                   (1, 3, T(-3)),
                                   (n, n-2, T(-3)),
-                                  (1, 4, one(T)),
-                                  (n, n-3, one(T))
+                                  (1, 4, oneunit(T)),
+                                  (n, n-3, oneunit(T))
                                   )
 
     Woodbury(lufact!(Tridiagonal(dl, d, du), Val{false}), specs...), zeros(TC, n)
@@ -251,8 +251,8 @@ function prefiltering_system{T,TC}(::Type{T}, ::Type{TC}, n::Int,
     specs = WoodburyMatrices.sparse_factors(T, n,
                                   (1, 3, T(5)),
                                   (n, n-2, T(5)),
-                                  (1, 4, -one(T)),
-                                  (n, n-3, -one(T))
+                                  (1, 4, -oneunit(T)),
+                                  (n, n-3, -oneunit(T))
                                   )
 
     Woodbury(lufact!(Tridiagonal(dl, d, du), Val{false}), specs...), zeros(TC, n)
@@ -273,8 +273,8 @@ function prefiltering_system{T,TC}(::Type{T}, ::Type{TC}, n::Int,
     # now need Woodbury correction to set :
     #    - [1, 3] and [n, n-2] ==> 1
     specs = WoodburyMatrices.sparse_factors(T, n,
-                                  (1, 3, one(T)),
-                                  (n, n-2, one(T)),
+                                  (1, 3, oneunit(T)),
+                                  (n, n-2, oneunit(T)),
                                   )
 
     Woodbury(lufact!(Tridiagonal(dl, d, du), Val{false}), specs...), zeros(TC, n)

src/b-splines/cubic.jl

@@ -198,8 +198,8 @@ function prefiltering_system{T,TC,BC<:Union{Flat,Reflect}}(::Type{T}, ::Type{TC}
     du[1] = dl[end] = 0
 
     specs = WoodburyMatrices.sparse_factors(T, n,
-                                  (1, 3, one(T)),
-                                  (n, n-2, one(T))
+                                  (1, 3, oneunit(T)),
+                                  (n, n-2, oneunit(T))
                                  )
 
     Woodbury(lufact!(Tridiagonal(dl, d, du), Val{false}), specs...), zeros(TC, n)
@@ -218,8 +218,8 @@ function prefiltering_system{T,TC,GT<:GridType}(::Type{T}, ::Type{TC}, n::Int, :
     du[1] = dl[end] = -2
 
     specs = WoodburyMatrices.sparse_factors(T, n,
-                                  (1, 3, one(T)),
-                                  (n, n-2, one(T)),
+                                  (1, 3, oneunit(T)),
+                                  (n, n-2, oneunit(T)),
                                   )
 
     Woodbury(lufact!(Tridiagonal(dl, d, du), Val{false}), specs...), zeros(TC, n)

src/b-splines/quadratic.jl

@@ -24,11 +24,11 @@ function GriddedInterpolation{N,TCoefs,TWeights<:Real,IT<:DimSpec{Gridded},pad}(
         issorted(k) || error("knot-vectors must be sorted in increasing order")
         iextract(IT, d) != NoInterp || k == collect(1:size(A, d)) || error("knot-vector should be the range 1:$(size(A,d)) for the method Gridded{NoInterp}")
     end
-    c = one(TWeights)
+    c = zero(TWeights)
     for _ in 2:N
         c *= c
     end
-    T = typeof(c * one(TCoefs))
+    T = typeof(c * zero(TCoefs))
 
     GriddedInterpolation{T,N,TCoefs,IT,typeof(knts),pad}(knts, A)
 end

src/gridded/gridded.jl

@@ -68,12 +68,12 @@ Returns *half* the width of one step of the range.
 This function is used to calculate the upper and lower bounds of `OnCell` interpolation objects.
 """ boundstep
 
-coordlookup(r::UnitRange, x) = x - r.start + one(eltype(r))
+coordlookup(r::UnitRange, x) = x - r.start + oneunit(eltype(r))
 coordlookup(i::Bool, r::Range, x) = i ? coordlookup(r, x) : convert(typeof(coordlookup(r,x)), x)
-coordlookup(r::StepRange, x) = (x - r.start) / r.step + one(eltype(r))
+coordlookup(r::StepRange, x) = (x - r.start) / r.step + oneunit(eltype(r))
 
 @static if isdefined(:StepRangeLen)
-    coordlookup(r::StepRangeLen, x) = (x - first(r)) / step(r) + one(eltype(r))
+    coordlookup(r::StepRangeLen, x) = (x - first(r)) / step(r) + oneunit(eltype(r))
     boundstep(r::StepRangeLen) = 0.5*step(r)
     rescale_gradient(r::StepRangeLen, g) = g / step(r)
 end
@@ -113,7 +113,7 @@ rescale_gradient(r::UnitRange, g) = g
     rescale_gradient(r::LinSpace, g) = g * r.divisor / (r.stop - r.start)
     rescale_gradient(r::FloatRange, g) = g * r.divisor / r.step
     coordlookup(r::LinSpace, x) = (r.divisor * x + r.stop - r.len * r.start) / (r.stop - r.start)
-    coordlookup(r::FloatRange, x) = (r.divisor * x - r.start) / r.step + one(eltype(r))
+    coordlookup(r::FloatRange, x) = (r.divisor * x - r.start) / r.step + oneunit(eltype(r))
     boundstep(r::LinSpace) = ((r.stop - r.start) / r.divisor) / 2
     boundstep(r::FloatRange) = r.step / 2
 end