Deprecate vectorized two-argument complex methods in favor of compact broadcast syntax. (#19712)

Author: Sacha0

base/complex.jl

@@ -867,49 +867,3 @@ end
 ## promotion to complex ##
 
 _default_type(T::Type{Complex}) = Complex{Int}
-
-function complex{S<:Real,T<:Real}(A::AbstractArray{S}, B::AbstractArray{T})
-    if size(A) != size(B); throw(DimensionMismatch()); end
-    F = similar(A, typeof(complex(zero(S),zero(T))))
-    RF, RA, RB = eachindex(F), eachindex(A), eachindex(B)
-    if RF == RA == RB
-        for i in RA
-            @inbounds F[i] = complex(A[i], B[i])
-        end
-    else
-        for (iF, iA, iB) in zip(RF, RA, RB)
-            @inbounds F[iF] = complex(A[iA], B[iB])
-        end
-    end
-    return F
-end
-
-function complex{T<:Real}(A::Real, B::AbstractArray{T})
-    F = similar(B, typeof(complex(A,zero(T))))
-    RF, RB = eachindex(F), eachindex(B)
-    if RF == RB
-        for i in RB
-            @inbounds F[i] = complex(A, B[i])
-        end
-    else
-        for (iF, iB) in zip(RF, RB)
-            @inbounds F[iF] = complex(A, B[iB])
-        end
-    end
-    return F
-end
-
-function complex{T<:Real}(A::AbstractArray{T}, B::Real)
-    F = similar(A, typeof(complex(zero(T),B)))
-    RF, RA = eachindex(F), eachindex(A)
-    if RF == RA
-        for i in RA
-            @inbounds F[i] = complex(A[i], B)
-        end
-    else
-        for (iF, iA) in zip(RF, RA)
-            @inbounds F[iF] = complex(A[iA], B)
-        end
-    end
-    return F
-end

base/deprecated.jl

@@ -1380,6 +1380,11 @@ for f in (:sec, :sech, :secd, :asec, :asech,
     @eval @deprecate $f{T<:Number}(A::AbstractArray{T}) $f.(A)
 end
 
+# Deprecate vectorized two-argument complex in favor of compact broadcast syntax
+@deprecate complex(A::AbstractArray, b::Real)           complex.(A, b)
+@deprecate complex(a::Real, B::AbstractArray)           complex.(a, B)
+@deprecate complex(A::AbstractArray, B::AbstractArray)  complex.(A, B)
+
 # Deprecate manually vectorized clamp methods in favor of compact broadcast syntax
 @deprecate clamp(A::AbstractArray, lo, hi) clamp.(A, lo, hi)
 

base/linalg/arpack.jl

@@ -171,7 +171,7 @@ function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::String,
         if info[1] != 0
             throw(ARPACKException(info[1]))
         end
-        evec = complex(Array{T}(n, nev+1), Array{T}(n, nev+1))
+        evec = complex.(Array{T}(n, nev+1), Array{T}(n, nev+1))
 
         j = 1
         while j <= nev
@@ -193,7 +193,7 @@ function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::String,
             end
         end
 
-        d = complex(dr,di)
+        d = complex.(dr, di)
 
         if j == nev+1
             p = sortperm(dmap(d[1:nev]), rev=true)

base/linalg/blas.jl

@@ -235,7 +235,7 @@ conjugating the first vector.
 
 # Example:
 ```jldoctest
-julia> Base.BLAS.dotc(10, im*ones(10), 1, complex(ones(20), ones(20)), 2)
+julia> Base.BLAS.dotc(10, im*ones(10), 1, complex.(ones(20), ones(20)), 2)
 10.0 - 10.0im
 ```
 """
@@ -249,7 +249,7 @@ with stride `incx` and `n` elements of array `Y` with stride `incy`.
 
 # Example:
 ```jldoctest
-julia> Base.BLAS.dotu(10, im*ones(10), 1, complex(ones(20), ones(20)), 2)
+julia> Base.BLAS.dotu(10, im*ones(10), 1, complex.(ones(20), ones(20)), 2)
 -10.0 + 10.0im
 ```
 """

base/linalg/eigen.jl

@@ -45,7 +45,7 @@ function eigfact!{T<:BlasReal}(A::StridedMatrix{T}; permute::Bool=true, scale::B
         end
         j += 1
     end
-    return Eigen(complex(WR, WI), evec)
+    return Eigen(complex.(WR, WI), evec)
 end
 
 function eigfact!{T<:BlasComplex}(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true)
@@ -162,7 +162,7 @@ make rows and columns more equal in norm.
 function eigvals!{T<:BlasReal}(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true)
     issymmetric(A) && return eigvals!(Symmetric(A))
     _, valsre, valsim, _ = LAPACK.geevx!(permute ? (scale ? 'B' : 'P') : (scale ? 'S' : 'N'), 'N', 'N', 'N', A)
-    return iszero(valsim) ? valsre : complex(valsre, valsim)
+    return iszero(valsim) ? valsre : complex.(valsre, valsim)
 end
 function eigvals!{T<:BlasComplex}(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true)
     ishermitian(A) && return eigvals(Hermitian(A))
@@ -297,7 +297,7 @@ function eigfact!{T<:BlasReal}(A::StridedMatrix{T}, B::StridedMatrix{T})
         end
         j += 1
     end
-    return GeneralizedEigen(complex(alphar, alphai)./beta, vecs)
+    return GeneralizedEigen(complex.(alphar, alphai)./beta, vecs)
 end
 
 function eigfact!{T<:BlasComplex}(A::StridedMatrix{T}, B::StridedMatrix{T})
@@ -364,7 +364,7 @@ Same as [`eigvals`](@ref), but saves space by overwriting the input `A` (and `B`
 function eigvals!{T<:BlasReal}(A::StridedMatrix{T}, B::StridedMatrix{T})
     issymmetric(A) && isposdef(B) && return eigvals!(Symmetric(A), Symmetric(B))
     alphar, alphai, beta, vl, vr = LAPACK.ggev!('N', 'N', A, B)
-    return (iszero(alphai) ? alphar : complex(alphar, alphai))./beta
+    return (iszero(alphai) ? alphar : complex.(alphar, alphai))./beta
 end
 function eigvals!{T<:BlasComplex}(A::StridedMatrix{T}, B::StridedMatrix{T})
     ishermitian(A) && isposdef(B) && return eigvals!(Hermitian(A), Hermitian(B))

base/linalg/lapack.jl

@@ -5504,7 +5504,7 @@ for (gees, gges, elty) in
                     work = Array{$elty}(lwork)
                 end
             end
-            A, vs, iszero(wi) ? wr : complex(wr, wi)
+            A, vs, iszero(wi) ? wr : complex.(wr, wi)
         end
 
         # *     .. Scalar Arguments ..
@@ -5553,7 +5553,7 @@ for (gees, gges, elty) in
                     work = Array{$elty}(lwork)
                 end
             end
-            A, B, complex(alphar, alphai), beta, vsl[1:(jobvsl == 'V' ? n : 0),:], vsr[1:(jobvsr == 'V' ? n : 0),:]
+            A, B, complex.(alphar, alphai), beta, vsl[1:(jobvsl == 'V' ? n : 0),:], vsr[1:(jobvsr == 'V' ? n : 0),:]
         end
     end
 end
@@ -5753,7 +5753,7 @@ for (trexc, trsen, tgsen, elty) in
                     iwork  = Array{BlasInt}(liwork)
                 end
             end
-            T, Q, iszero(wi) ? wr : complex(wr, wi)
+            T, Q, iszero(wi) ? wr : complex.(wr, wi)
         end
         trsen!(select::StridedVector{BlasInt}, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty}) =
             trsen!('N', 'V', select, T, Q)
@@ -5822,7 +5822,7 @@ for (trexc, trsen, tgsen, elty) in
                     iwork = Array{BlasInt}(liwork)
                 end
             end
-            S, T, complex(alphar, alphai), beta, Q, Z
+            S, T, complex.(alphar, alphai), beta, Q, Z
         end
     end
 end

base/sharedarray.jl

@@ -537,8 +537,6 @@ function copy!(S::SharedArray, R::SharedArray)
     return S
 end
 
-complex(S1::SharedArray,S2::SharedArray) = convert(SharedArray, complex(S1.s, S2.s))
-
 function print_shmem_limits(slen)
     try
         if is_linux()

base/sparse/cholmod.jl

@@ -1572,7 +1572,7 @@ end
 Ac_ldiv_B(L::FactorComponent, B) = ctranspose(L)\B
 
 (\){T<:VTypes}(L::Factor{T}, B::Dense{T}) = solve(CHOLMOD_A, L, B)
-(\)(L::Factor{Float64}, B::VecOrMat{Complex{Float64}}) = complex(L\real(B), L\imag(B))
+(\)(L::Factor{Float64}, B::VecOrMat{Complex{Float64}}) = complex.(L\real(B), L\imag(B))
 # First explicit TypeVars are necessary to avoid ambiguity errors with definition in
 # linalg/factorizations.jl
 (\){T<:VTypes}(L::Factor{T}, b::StridedVector) = Vector(L\convert(Dense{T}, b))

base/sparse/sparsematrix.jl

@@ -354,8 +354,6 @@ float(S::SparseMatrixCSC) = SparseMatrixCSC(S.m, S.n, copy(S.colptr), copy(S.row
 
 complex(S::SparseMatrixCSC) = SparseMatrixCSC(S.m, S.n, copy(S.colptr), copy(S.rowval), complex(copy(S.nzval)))
 
-complex(A::SparseMatrixCSC, B::SparseMatrixCSC) = A + im*B
-
 # Construct a sparse vector
 
 # Note that unlike `vec` for arrays, this does not share data

base/sparse/umfpack.jl

@@ -370,8 +370,8 @@ for itype in UmfpackIndexTypes
                         Up,Ui,Ux,Uz,
                         P, Q, C_NULL, C_NULL,
                         &0, Rs, lu.numeric)
-            (transpose(SparseMatrixCSC(min(n_row, n_col), n_row, increment!(Lp), increment!(Lj), complex(Lx, Lz))),
-             SparseMatrixCSC(min(n_row, n_col), n_col, increment!(Up), increment!(Ui), complex(Ux, Uz)),
+            (transpose(SparseMatrixCSC(min(n_row, n_col), n_row, increment!(Lp), increment!(Lj), complex.(Lx, Lz))),
+             SparseMatrixCSC(min(n_row, n_col), n_col, increment!(Up), increment!(Ui), complex.(Ux, Uz)),
              increment!(P), increment!(Q), Rs)
         end
     end