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

Sacha0 · Sacha0 · commit e5a07f9583af · 2016-09-14T16:36:35.000-07:00
diff --git a/base/broadcast.jl b/base/broadcast.jl
@@ -5,7 +5,8 @@ module Broadcast
 using Base.Cartesian
 using Base: promote_eltype_op, @get!, _msk_end, unsafe_bitgetindex, linearindices, tail, OneTo, to_shape
 import Base: .+, .-, .*, ./, .\, .//, .==, .<, .!=, .<=, .÷, .%, .<<, .>>, .^
-export broadcast, broadcast!, bitbroadcast, dotview
+import Base: broadcast
+export broadcast!, bitbroadcast, dotview
 export broadcast_getindex, broadcast_setindex!
 
 ## Broadcasting utilities ##
diff --git a/base/complex.jl b/base/complex.jl
@@ -828,8 +828,8 @@ function complex{T}(A::AbstractArray{T})
     convert(AbstractArray{typeof(complex(zero(T)))}, A)
 end
 
-big{T<:Integer,N}(A::AbstractArray{Complex{T},N}) = convert(AbstractArray{Complex{BigInt},N}, A)
-big{T<:AbstractFloat,N}(A::AbstractArray{Complex{T},N}) = convert(AbstractArray{Complex{BigFloat},N}, A)
+broadcast{T<:Integer,N}(::typeof(big), A::AbstractArray{Complex{T},N}) = convert(AbstractArray{Complex{BigInt},N}, A)
+broadcast{T<:AbstractFloat,N}(::typeof(big), A::AbstractArray{Complex{T},N}) = convert(AbstractArray{Complex{BigFloat},N}, A)
 
 ## promotion to complex ##
 
diff --git a/base/deprecated.jl b/base/deprecated.jl
@@ -1000,4 +1000,20 @@ macro vectorize_2arg(S,f)
 end
 export @vectorize_1arg, @vectorize_2arg
 
+# Deprecate manually vectorized `big` methods in favor of compact broadcast syntax
+@deprecate big(r::UnitRange) big.(r)
+@deprecate big(r::StepRange) big.(r)
+@deprecate big(r::FloatRange) big.(r)
+@deprecate big(r::LinSpace) big.(r)
+@deprecate big{T<:Integer,N}(x::AbstractArray{T,N}) big.(x)
+@deprecate big{T<:AbstractFloat,N}(x::AbstractArray{T,N}) big.(x)
+@deprecate big(A::LowerTriangular) big.(A)
+@deprecate big(A::UpperTriangular) big.(A)
+@deprecate big(A::Base.LinAlg.UnitLowerTriangular) big.(A)
+@deprecate big(A::Base.LinAlg.UnitUpperTriangular) big.(A)
+@deprecate big(B::Bidiagonal) big.(B)
+@deprecate big{T<:Integer,N}(A::AbstractArray{Complex{T},N}) big.(A)
+@deprecate big{T<:AbstractFloat,N}(A::AbstractArray{Complex{T},N}) big.(A)
+@deprecate big{T<:Integer,N}(x::AbstractArray{Complex{Rational{T}},N}) big.(A)
+
 # End deprecations scheduled for 0.6
diff --git a/base/float.jl b/base/float.jl
@@ -541,7 +541,7 @@ function float{T}(A::AbstractArray{T})
     convert(AbstractArray{typeof(float(zero(T)))}, A)
 end
 
-for fn in (:float,:big)
+for fn in (:float,)
     @eval begin
         $fn(r::StepRange) = $fn(r.start):$fn(r.step):$fn(last(r))
         $fn(r::UnitRange) = $fn(r.start):$fn(last(r))
@@ -554,5 +554,15 @@ for fn in (:float,:big)
     end
 end
 
-big{T<:AbstractFloat,N}(x::AbstractArray{T,N}) = convert(AbstractArray{BigFloat,N}, x)
-big{T<:Integer,N}(x::AbstractArray{T,N}) = convert(AbstractArray{BigInt,N}, x)
+# big, broadcast over arrays
+# TODO: do the definitions below primarily pertaining to integers belong in float.jl?
+function big end # no prior definitions of big in sysimg.jl, necessitating this
+broadcast{T<:Integer,N}(::typeof(big), x::AbstractArray{T,N}) = convert(AbstractArray{BigInt,N}, x)
+broadcast{T<:AbstractFloat,N}(::typeof(big), x::AbstractArray{T,N}) = convert(AbstractArray{BigFloat,N}, x)
+broadcast(::typeof(big), r::UnitRange) = big(r.start):big(last(r))
+broadcast(::typeof(big), r::StepRange) = big(r.start):big(r.step):big(last(r))
+broadcast(::typeof(big), r::FloatRange) = FloatRange(big(r.start), big(r.step), r.len, big(r.divisor))
+function broadcast(::typeof(big), r::LinSpace)
+    big(r.len) == r.len || throw(ArgumentError(string(r, ": too long for ", big)))
+    LinSpace(big(r.start), big(r.stop), big(r.len), big(r.divisor))
+end
diff --git a/base/linalg/bidiag.jl b/base/linalg/bidiag.jl
@@ -148,7 +148,7 @@ convert{Tnew,Told}(::Type{Bidiagonal{Tnew}}, A::Bidiagonal{Told}) = Bidiagonal(c
 # When asked to convert Bidiagonal{Told} to AbstractMatrix{Tnew}, preserve structure by converting to Bidiagonal{Tnew} <: AbstractMatrix{Tnew}
 convert{Tnew,Told}(::Type{AbstractMatrix{Tnew}}, A::Bidiagonal{Told}) = convert(Bidiagonal{Tnew}, A)
 
-big(B::Bidiagonal) = Bidiagonal(big(B.dv), big(B.ev), B.isupper)
+broadcast(::typeof(big), B::Bidiagonal) = Bidiagonal(big.(B.dv), big.(B.ev), B.isupper)
 
 similar{T}(B::Bidiagonal, ::Type{T}) = Bidiagonal{T}(similar(B.dv, T), similar(B.ev, T), B.isupper)
 
diff --git a/base/linalg/triangular.jl b/base/linalg/triangular.jl
@@ -32,7 +32,7 @@ for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular,
 
         copy(A::$t) = $t(copy(A.data))
 
-        big(A::$t) = $t(big(A.data))
+        broadcast(::typeof(big), A::$t) = $t(big.(A.data))
 
         real{T<:Real}(A::$t{T}) = A
         real{T<:Complex}(A::$t{T}) = (B = real(A.data); $t(B))
diff --git a/base/rational.jl b/base/rational.jl
@@ -82,7 +82,8 @@ convert(::Type{Rational}, x::Float64) = convert(Rational{Int64}, x)
 convert(::Type{Rational}, x::Float32) = convert(Rational{Int}, x)
 
 big{T<:Integer}(z::Complex{Rational{T}}) = Complex{Rational{BigInt}}(z)
-big{T<:Integer,N}(x::AbstractArray{Complex{Rational{T}},N}) = convert(AbstractArray{Complex{Rational{BigInt}},N}, x)
+broadcast{T<:Integer,N}(::typeof(big), x::AbstractArray{Complex{Rational{T}},N}) =
+    convert(AbstractArray{Complex{Rational{BigInt}},N}, x)
 
 promote_rule{T<:Integer,S<:Integer}(::Type{Rational{T}}, ::Type{S}) = Rational{promote_type(T,S)}
 promote_rule{T<:Integer,S<:Integer}(::Type{Rational{T}}, ::Type{Rational{S}}) = Rational{promote_type(T,S)}
diff --git a/test/bigint.jl b/test/bigint.jl
@@ -275,10 +275,10 @@ ndigits_mismatch(n) = ndigits(n) != ndigits(BigInt(n))
 @test !any(ndigits_mismatch, 8192:9999)
 
 # The following should not crash (#16579)
-ndigits(rand(big(-999:999)), rand(63:typemax(Int)))
-ndigits(rand(big(-999:999)), big(2)^rand(2:999))
+ndigits(rand(big.(-999:999)), rand(63:typemax(Int)))
+ndigits(rand(big.(-999:999)), big(2)^rand(2:999))
 
-for i in big([-20:-1;1:20])
+for i in big.([-20:-1;1:20])
     for b in -10:1
         @test_throws DomainError ndigits(i, b)
     end
diff --git a/test/linalg/arnoldi.jl b/test/linalg/arnoldi.jl
@@ -228,9 +228,9 @@ end
 eigs(rand(1:10, 10, 10))
 eigs(rand(1:10, 10, 10), rand(1:10, 10, 10) |> t -> t't)
 svds(rand(1:10, 10, 8))
-@test_throws MethodError eigs(big(rand(1:10, 10, 10)))
-@test_throws MethodError eigs(big(rand(1:10, 10, 10)), rand(1:10, 10, 10))
-@test_throws MethodError svds(big(rand(1:10, 10, 8)))
+@test_throws MethodError eigs(big.(rand(1:10, 10, 10)))
+@test_throws MethodError eigs(big.(rand(1:10, 10, 10)), rand(1:10, 10, 10))
+@test_throws MethodError svds(big.(rand(1:10, 10, 8)))
 
 # Symmetric generalized with singular B
 let
diff --git a/test/linalg/bidiag.jl b/test/linalg/bidiag.jl
@@ -64,7 +64,7 @@ for relty in (Int, Float32, Float64, BigFloat), elty in (relty, Complex{relty})
         @test size(T) == (n, n)
         @test full(T) == diagm(dv) + diagm(ev, isupper?1:-1)
         @test Bidiagonal(full(T), isupper) == T
-        @test big(T) == T
+        @test big.(T) == T
         @test full(abs.(T)) == abs.(diagm(dv)) + abs.(diagm(ev, isupper?1:-1))
         @test full(real(T)) == real(diagm(dv)) + real(diagm(ev, isupper?1:-1))
         @test full(imag(T)) == imag(diagm(dv)) + imag(diagm(ev, isupper?1:-1))
diff --git a/test/linalg/generic.jl b/test/linalg/generic.jl
@@ -224,7 +224,7 @@ for elty in [Float32,Float64,Complex64,Complex128]
 end
 
 @test rank([1.0 0.0; 0.0 0.9],0.95) == 1
-@test qr(big([0 1; 0 0]))[2] == [0 1; 0 0]
+@test qr(big.([0 1; 0 0]))[2] == [0 1; 0 0]
 
 @test norm([2.4e-322, 4.4e-323]) ≈ 2.47e-322
 @test norm([2.4e-322, 4.4e-323], 3) ≈ 2.4e-322
diff --git a/test/linalg/qr.jl b/test/linalg/qr.jl
@@ -148,8 +148,8 @@ end
 @test_throws ErrorException ctranspose(qrfact(randn(3,3)))
 @test_throws ErrorException transpose(qrfact(randn(3,3), Val{false}))
 @test_throws ErrorException ctranspose(qrfact(randn(3,3), Val{false}))
-@test_throws ErrorException transpose(qrfact(big(randn(3,3))))
-@test_throws ErrorException ctranspose(qrfact(big(randn(3,3))))
+@test_throws ErrorException transpose(qrfact(big.(randn(3,3))))
+@test_throws ErrorException ctranspose(qrfact(big.(randn(3,3))))
 
 # Issue 7304
 let
diff --git a/test/linalg/triangular.jl b/test/linalg/triangular.jl
@@ -417,7 +417,7 @@ for eltya in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
         x = Atri \ b
         γ = n*ε/(1 - n*ε)
         if eltya != BigFloat
-            bigA = big(Atri)
+            bigA = big.(Atri)
             x̂ = ones(n, 2)
             for i = 1:size(b, 2)
                 @test norm(x̂[:,i] - x[:,i], Inf)/norm(x̂[:,i], Inf) <= condskeel(bigA, x̂[:,i])*γ/(1 - condskeel(bigA)*γ)
@@ -446,7 +446,7 @@ for eltya in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
         x = Atri \ b
         γ = n*ε/(1 - n*ε)
         if eltya != BigFloat
-            bigA = big(Atri)
+            bigA = big.(Atri)
             x̂ = ones(n, 2)
             for i = 1:size(b, 2)
                 @test norm(x̂[:,i] - x[:,i], Inf)/norm(x̂[:,i], Inf) <= condskeel(bigA, x̂[:,i])*γ/(1 - condskeel(bigA)*γ)
diff --git a/test/numbers.jl b/test/numbers.jl
@@ -2603,8 +2603,8 @@ end
 for (d,B) in ((4//2+1im,Rational{BigInt}),(3.0+1im,BigFloat),(2+1im,BigInt))
     @test typeof(big(d)) == Complex{B}
     @test big(d) == d
-    @test typeof(big([d])) == Vector{Complex{B}}
-    @test big([d]) == [d]
+    @test typeof(big.([d])) == Vector{Complex{B}}
+    @test big.([d]) == [d]
 end
 
 # issue #12536
diff --git a/test/random.jl b/test/random.jl
@@ -133,10 +133,10 @@ ke = Array{UInt64}(ziggurat_table_size)
 we = Array{Float64}(ziggurat_table_size)
 fe = Array{Float64}(ziggurat_table_size)
 function randmtzig_fill_ziggurat_tables() # Operates on the global arrays
-    wib = big(wi)
-    fib = big(fi)
-    web = big(we)
-    feb = big(fe)
+    wib = big.(wi)
+    fib = big.(fi)
+    web = big.(we)
+    feb = big.(fe)
     # Ziggurat tables for the normal distribution
     x1 = ziggurat_nor_r
     wib[256] = x1/nmantissa
diff --git a/test/ranges.jl b/test/ranges.jl
@@ -659,7 +659,7 @@ test_linspace_identity(linspace(1f0, 1f0, 1), linspace(-1f0, -1f0, 1))
 for _r in (1:2:100, 1:100, 1f0:2f0:100f0, 1.0:2.0:100.0,
            linspace(1, 100, 10), linspace(1f0, 100f0, 10))
     float_r = float(_r)
-    big_r = big(_r)
+    big_r = big.(_r)
     @test typeof(big_r).name === typeof(_r).name
     if eltype(_r) <: AbstractFloat
         @test isa(float_r, typeof(_r))
