itrunc -> trunc, etc, fix Int128 vs float comparisons

NEWS.md

@@ -140,6 +140,12 @@ Deprecated or removed
 
   * `{...}` syntax is deprecated in favor of `Any[...]` ([#8578]).
 
+  * `itrunc`, `ifloor`, `iceil` and `iround` are deprecated in favour of
+  `trunc{T<:Integer}(T,x)`, `floor{T<:Integer}(T,x)`, etc.. `trunc` is now
+  always bound-checked;`Base.unsafe_trunc` provides the old unchecked `itrunc`
+  behaviour ([#9133]).
+
+
 Julia v0.3.0 Release Notes
 ==========================
 

base/abstractarray.jl

@@ -1385,7 +1385,7 @@ function randsubseq!(S::AbstractArray, A::AbstractArray, p::Real)
     empty!(S)
     p == 0 && return S
     nexpected = p * length(A)
-    sizehint(S, iround(nexpected + 5*sqrt(nexpected)))
+    sizehint(S, round(Int,nexpected + 5*sqrt(nexpected)))
     if p > 0.15 # empirical threshold for trivial O(n) algorithm to be better
         for i = 1:n
             rand() <= p && push!(S, A[i])
@@ -1396,14 +1396,14 @@ function randsubseq!(S::AbstractArray, A::AbstractArray, p::Real)
         # s==k (k > 0) is (1-p)^(k-1) * p, and hence the probability (CDF) that
         # s is in {1,...,k} is 1-(1-p)^k = F(k).   Thus, we can draw the skip s
         # from this probability distribution via the discrete inverse-transform
-        # method: s = iceil(F^{-1}(u)) where u = rand(), which is simply
-        # s = iceil(log(rand()) / log1p(-p)).
+        # method: s = ceil(F^{-1}(u)) where u = rand(), which is simply
+        # s = ceil(log(rand()) / log1p(-p)).
         L = 1 / log1p(-p)
         i = 0
         while true
             s = log(rand()) * L # note that rand() < 1, so s > 0
-            s >= n - i && return S # compare before iceil to avoid overflow
-            push!(S, A[i += iceil(s)])
+            s >= n - i && return S # compare before ceil to avoid overflow
+            push!(S, A[i += ceil(Int,s)])
         end
         # [This algorithm is similar in spirit to, but much simpler than,
         #  the one by Vitter for a related problem in "Faster methods for

base/bitarray.jl

@@ -790,10 +790,7 @@ function empty!(B::BitVector)
 end
 
 ## Misc functions
-
-for f in (:iround, :itrunc, :ifloor, :iceil, :abs)
-    @eval ($f)(B::BitArray) = copy(B)
-end
+abs(B::BitArray) = copy(B)
 
 ## Unary operators ##
 

base/char.jl

@@ -1,5 +1,5 @@
 char(x) = convert(Char, x)
-char(x::FloatingPoint) = char(iround(x))
+char(x::FloatingPoint) = char(round(UInt32,x))
 
 integer(x::Char) = int(x)
 

base/complex.jl

@@ -477,21 +477,19 @@ function ^{T<:Complex}(z::T, p::T)
 
     # apply some corrections to force known zeros
     if pim == 0
-        ip = itrunc(pr)
-        if ip == pr
+        if isinteger(pr)
             if zi == 0
                 im = copysign(zero(im), im)
             elseif zr == 0
-                if isodd(ip)
-                    re = copysign(zero(re), re)
-                else
+                if isinteger(0.5*pr) # pr is even
                     im = copysign(zero(im), im)
+                else
+                    re = copysign(zero(re), re)
                 end
             end
         else
             dr = pr*2
-            ip = itrunc(dr)
-            if ip == dr && zi == 0
+            if isinteger(dr) && zi == 0
                 if zr < 0
                     re = copysign(zero(re), re)
                 else

base/darray.jl

@@ -94,7 +94,7 @@ end
 # get array of start indexes for dividing sz into nc chunks
 function defaultdist(sz::Int, nc::Int)
     if sz >= nc
-        iround(linspace(1, sz+1, nc+1))
+        round(Int,linspace(1, sz+1, nc+1))
     else
         [[1:(sz+1)], zeros(Int, nc-sz)]
     end

base/dates/ranges.jl

@@ -4,7 +4,7 @@
 Base.colon{T<:DateTime}(start::T, stop::T) = StepRange(start, Day(1), stop)
 
 # Given a start and end date, how many steps/periods are in between
-guess(a::DateTime,b::DateTime,c) = ifloor(Int64,(int128(b) - int128(a))/toms(c))
+guess(a::DateTime,b::DateTime,c) = floor(Int64,(int128(b) - int128(a))/toms(c))
 guess(a::Date,b::Date,c) = int64(div(int64(b - a),days(c)))
 function len(a,b,c)
     lo, hi, st = min(a,b), max(a,b), abs(c)

base/deprecated.jl

@@ -231,3 +231,12 @@ const Uint128 = UInt128
 
 @deprecate rand!(r::Range, A::AbstractArray) rand!(A, r)
 @deprecate rand!(mt::MersenneTwister, r::Range, A::AbstractArray) rand!(mt, A, r)
+
+@deprecate itrunc(x)              trunc(Integer,x)
+@deprecate itrunc{T<:Integer}(::Type{T},x::Real) trunc(T,x)
+@deprecate iceil(x)               ceil(Integer,x)
+@deprecate iceil{T}(::Type{T},x)  ceil(T,x)
+@deprecate ifloor(x)              floor(Integer,x)
+@deprecate ifloor{T}(::Type{T},x) floor(T,x)
+@deprecate iround(x)              round(Integer,x)
+@deprecate iround{T}(::Type{T},x) round(T,x)

base/exports.jl

@@ -360,8 +360,6 @@ export
     gcdx,
     hex2num,
     hypot,
-    iceil,
-    ifloor,
     imag,
     int,
     int128,
@@ -373,7 +371,6 @@ export
     inv,
     invdigamma,
     invmod,
-    iround,
     isapprox,
     iseltype,
     iseven,
@@ -387,7 +384,6 @@ export
     isqrt,
     isreal,
     issubnormal,
-    itrunc,
     lcm,
     ldexp,
     leading_ones,