Merge pull request #159 from JuliaMath/teh/oneunit

Use zero and oneunit in place of one

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