Deprecate manually vectorized div methods in favor of compact broadcast syntax.

Author: Sacha0

base/arraymath.jl

@@ -66,7 +66,7 @@ promote_array_type{S<:Integer}(::typeof(/), ::Type{S}, ::Type{Bool}, T::Type) =
 promote_array_type{S<:Integer}(::typeof(\), ::Type{S}, ::Type{Bool}, T::Type) = T
 promote_array_type{S<:Integer}(F, ::Type{S}, ::Type{Bool}, T::Type) = T
 
-for f in (:+, :-, :div, :mod, :&, :|, :xor)
+for f in (:+, :-, :mod, :&, :|, :xor)
     @eval ($f)(A::AbstractArray, B::AbstractArray) =
         _elementwise($f, promote_eltype_op($f, A, B), A, B)
 end
@@ -89,7 +89,7 @@ function _elementwise{T}(op, ::Type{T}, A::AbstractArray, B::AbstractArray)
     return F
 end
 
-for f in (:div, :mod, :rem, :&, :|, :xor, :/, :\, :*, :+, :-)
+for f in (:mod, :rem, :&, :|, :xor, :/, :\, :*, :+, :-)
     if f != :/
         @eval function ($f){T}(A::Number, B::AbstractArray{T})
             R = promote_op($f, typeof(A), T)

base/bitarray.jl

@@ -1237,21 +1237,19 @@ end
 (/)(B::BitArray, x::Number) = (/)(Array(B), x)
 (/)(x::Number, B::BitArray) = (/)(x, Array(B))
 
-function div(A::BitArray, B::BitArray)
+function broadcast(::typeof(div), A::BitArray, B::BitArray)
     shp = promote_shape(size(A), size(B))
     all(B) || throw(DivideError())
     return reshape(copy(A), shp)
 end
-div(A::BitArray, B::Array{Bool}) = div(A, BitArray(B))
-div(A::Array{Bool}, B::BitArray) = div(BitArray(A), B)
-function div(B::BitArray, x::Bool)
-    return x ? copy(B) : throw(DivideError())
-end
-function div(x::Bool, B::BitArray)
+broadcast(::typeof(div), A::BitArray, B::Array{Bool}) = div.(A, BitArray(B))
+broadcast(::typeof(div), A::Array{Bool}, B::BitArray) = div.(BitArray(A), B)
+broadcast(::typeof(div), B::BitArray, x::Bool) = x ? copy(B) : throw(DivideError())
+function broadcast(::typeof(div), x::Bool, B::BitArray)
     all(B) || throw(DivideError())
     return x ? trues(size(B)) : falses(size(B))
 end
-function div(x::Number, B::BitArray)
+function broadcast(::typeof(div), x::Number, B::BitArray)
     all(B) || throw(DivideError())
     y = div(x, true)
     return fill(y, size(B))
@@ -1276,8 +1274,17 @@ function mod(x::Number, B::BitArray)
     y = mod(x, true)
     return fill(y, size(B))
 end
+function broadcast(::typeof(div), B::BitArray, x::Number)
+    T = promote_op(div, Bool, typeof(x))
+    T === Any && return [div(b, x) for b in B]
+    F = Array{T}(size(B))
+    for i = 1:length(F)
+        F[i] = div(B[i], x)
+    end
+    return F
+end
 
-for f in (:div, :mod)
+for f in (:mod,)
     @eval begin
         function ($f)(B::BitArray, x::Number)
             T = promote_op($f, Bool, typeof(x))

base/deprecated.jl

@@ -1168,4 +1168,9 @@ for (dep, f, op) in [(:sumabs!, :sum!, :abs),
     end
 end
 
+# Deprecate manually vectorized div methods in favor of compact broadcast syntax
+@deprecate div(A::Number, B::AbstractArray) div.(A, B)
+@deprecate div(A::AbstractArray, B::Number) div.(A, B)
+@deprecate div(A::AbstractArray, B::AbstractArray) div.(A, B)
+
 # End deprecations scheduled for 0.6

base/dft.jl

@@ -354,7 +354,7 @@ plan_irfft
 
 export fftshift, ifftshift
 
-fftshift(x) = circshift(x, div([size(x)...],2))
+fftshift(x) = circshift(x, div.([size(x)...],2))
 
 """
     fftshift(x)
@@ -376,7 +376,7 @@ Swap the first and second halves of the given dimension of array `x`.
 """
 fftshift(x,dim)
 
-ifftshift(x) = circshift(x, div([size(x)...],-2))
+ifftshift(x) = circshift(x, div.([size(x)...],-2))
 
 """
     ifftshift(x, [dim])

test/bitarray.jl

@@ -13,24 +13,41 @@ tc(r1,r2) = false
 bitcheck(b::BitArray) = Base._check_bitarray_consistency(b)
 bitcheck(x) = true
 
-function check_bitop(ret_type, func, args...)
+function check_bitop_call(ret_type, func, args...)
     r1 = func(args...)
     r2 = func(map(x->(isa(x, BitArray) ? Array(x) : x), args)...)
+    check_bitop_tests(ret_type, r1, r2)
+end
+function check_bitop_dotcall(ret_type, func, args...)
+    r1 = func.(args...)
+    r2 = func.(map(x->(isa(x, BitArray) ? Array(x) : x), args)...)
+    check_bitop_tests(ret_type, r1, r2)
+end
+function check_bitop_tests(ret_type, r1, r2)
     ret_type ≢ nothing && !isa(r1, ret_type) && @show ret_type, r1
     ret_type ≢ nothing && @test isa(r1, ret_type)
     @test tc(r1, r2)
     @test isequal(r1, ret_type ≡ nothing ? r2 : convert(ret_type, r2))
     @test bitcheck(r1)
 end
-
 macro check_bit_operation(ex, ret_type)
-    @assert Meta.isexpr(ex, :call)
-    Expr(:call, :check_bitop, esc(ret_type), map(esc,ex.args)...)
+    if Meta.isexpr(ex, :call)
+        Expr(:call, :check_bitop_call, esc(ret_type), map(esc, ex.args)...)
+    elseif Meta.isexpr(ex, :.)
+        Expr(:call, :check_bitop_dotcall, esc(ret_type), esc(ex.args[1]), map(esc, ex.args[2].args)...)
+    else
+        throw(ArgumentError("first argument to @check_bit_operation must be an expression with head either :call or :. !"))
+    end
 end
 
 macro check_bit_operation(ex)
-    @assert Meta.isexpr(ex, :call)
-    Expr(:call, :check_bitop, nothing, map(esc,ex.args)...)
+    if Meta.isexpr(ex, :call)
+        Expr(:call, :check_bitop_call, nothing, map(esc, ex.args)...)
+    elseif Meta.isexpr(ex, :.)
+        Expr(:call, :check_bitop_dotcall, nothing, esc(ex.args[1]), map(esc, ex.args[2].args)...)
+    else
+        throw(ArgumentError("first argument to @check_bit_operation must be an expression with head either :call or :. !"))
+    end
 end
 
 let t0 = time()
@@ -793,11 +810,11 @@ let b1 = bitrand(n1, n2)
     @check_bit_operation (/)(b1,1) Matrix{Float64}
 
     b2 = trues(n1, n2)
-    @check_bit_operation div(b1, b2) BitMatrix
+    @check_bit_operation broadcast(div, b1, b2) BitMatrix
     @check_bit_operation mod(b1, b2) BitMatrix
-    @check_bit_operation div(b1,Array(b2)) BitMatrix
+    @check_bit_operation broadcast(div, b1, Array(b2)) BitMatrix
     @check_bit_operation mod(b1,Array(b2)) BitMatrix
-    @check_bit_operation div(Array(b1),b2) BitMatrix
+    @check_bit_operation broadcast(div, Array(b1), b2) BitMatrix
     @check_bit_operation mod(Array(b1),b2) BitMatrix
 end
 
@@ -832,7 +849,7 @@ let b1 = bitrand(n1, n2)
     @check_bit_operation broadcast(*, b1, i2) Matrix{Int}
     @check_bit_operation broadcast(/, b1, i2) Matrix{Float64}
     @check_bit_operation broadcast(^, b1, i2) BitMatrix
-    @check_bit_operation div(b1, i2)  Matrix{Int}
+    @check_bit_operation broadcast(div, b1, i2)  Matrix{Int}
     @check_bit_operation mod(b1, i2)  Matrix{Int}
 end
 
@@ -843,7 +860,7 @@ let b1 = bitrand(n1, n2)
     @check_bit_operation broadcast(*, b1, f2) Matrix{Float64}
     @check_bit_operation broadcast(/, b1, f2) Matrix{Float64}
     @check_bit_operation broadcast(^, b1, f2) Matrix{Float64}
-    @check_bit_operation div(b1, f2)  Matrix{Float64}
+    @check_bit_operation broadcast(div, b1, f2)  Matrix{Float64}
     @check_bit_operation mod(b1, f2)  Matrix{Float64}
 end
 
@@ -882,22 +899,22 @@ let b2 = bitrand(n1, n2)
 
     b2 = trues(n1, n2)
     @check_bit_operation broadcast(/, true, b2)  Matrix{Float64}
-    @check_bit_operation div(true, b2)   BitMatrix
+    @check_bit_operation broadcast(div, true, b2)   BitMatrix
     @check_bit_operation mod(true, b2)   BitMatrix
     @check_bit_operation broadcast(/, false, b2) Matrix{Float64}
-    @check_bit_operation div(false, b2)  BitMatrix
+    @check_bit_operation broadcast(div, false, b2)  BitMatrix
     @check_bit_operation mod(false, b2)  BitMatrix
 
     @check_bit_operation broadcast(/, i1, b2) Matrix{Float64}
-    @check_bit_operation div(i1, b2)  Matrix{Int}
+    @check_bit_operation broadcast(div, i1, b2)  Matrix{Int}
     @check_bit_operation mod(i1, b2)  Matrix{Int}
 
     @check_bit_operation broadcast(/, u1, b2) Matrix{Float64}
-    @check_bit_operation div(u1, b2)  Matrix{UInt8}
+    @check_bit_operation broadcast(div, u1, b2)  Matrix{UInt8}
     @check_bit_operation mod(u1, b2)  Matrix{UInt8}
 
     @check_bit_operation broadcast(/, f1, b2) Matrix{Float64}
-    @check_bit_operation div(f1, b2)  Matrix{Float64}
+    @check_bit_operation broadcast(div, f1, b2)  Matrix{Float64}
     @check_bit_operation mod(f1, b2)  Matrix{Float64}
 
     @check_bit_operation broadcast(/, ci1, b2) Matrix{Complex128}
@@ -955,7 +972,7 @@ let b1 = bitrand(n1, n2)
     @check_bit_operation broadcast(*, false, b1) BitMatrix
     @check_bit_operation broadcast(/, b1, true)  Matrix{Float64}
     @check_bit_operation broadcast(/, b1, false) Matrix{Float64}
-    @check_bit_operation div(b1, true)   BitMatrix
+    @check_bit_operation broadcast(div, b1, true)   BitMatrix
     @check_bit_operation mod(b1, true)   BitMatrix
 
     @check_bit_operation (&)(b1, b2)  BitMatrix
@@ -971,7 +988,7 @@ let b1 = bitrand(n1, n2)
     @check_bit_operation broadcast(-, b1, i2)  Matrix{Int}
     @check_bit_operation broadcast(*, b1, i2) Matrix{Int}
     @check_bit_operation broadcast(/, b1, i2) Matrix{Float64}
-    @check_bit_operation div(b1, i2)  Matrix{Int}
+    @check_bit_operation broadcast(div, b1, i2)  Matrix{Int}
     @check_bit_operation mod(b1, i2)  Matrix{Int}
 
     @check_bit_operation (&)(b1, u2)  Matrix{UInt8}
@@ -981,14 +998,14 @@ let b1 = bitrand(n1, n2)
     @check_bit_operation broadcast(-, b1, u2)  Matrix{UInt8}
     @check_bit_operation broadcast(*, b1, u2) Matrix{UInt8}
     @check_bit_operation broadcast(/, b1, u2) Matrix{Float64}
-    @check_bit_operation div(b1, u2)  Matrix{UInt8}
+    @check_bit_operation broadcast(div, b1, u2)  Matrix{UInt8}
     @check_bit_operation mod(b1, u2)  Matrix{UInt8}
 
     @check_bit_operation broadcast(+, b1, f2)  Matrix{Float64}
     @check_bit_operation broadcast(-, b1, f2)  Matrix{Float64}
     @check_bit_operation broadcast(*, b1, f2) Matrix{Float64}
     @check_bit_operation broadcast(/, b1, f2) Matrix{Float64}
-    @check_bit_operation div(b1, f2)  Matrix{Float64}
+    @check_bit_operation broadcast(div, b1, f2)  Matrix{Float64}
     @check_bit_operation mod(b1, f2)  Matrix{Float64}
 
     @check_bit_operation broadcast(+, b1, ci2)  Matrix{Complex{Int}}