deprecate Complex{32,64,128}

Cf. https://discourse.julialang.org/t/rename-complex2n-to-complexn/6081/6.

Author: rfourquet

NEWS.md

@@ -622,6 +622,10 @@ Deprecated or removed
   * `a:b` is deprecated for constructing a `StepRange` when `a` and `b` have physical units
     (Dates and Times). Use `a:s:b`, where `s = Dates.Day(1)` or `s = Dates.Second(1)`.
 
+  * The aliases `Complex32`, `Complex64` and `Complex128` have been deprecated in favor of `Complex{Float16}`,
+    `Complex{Float32}` and `Complex{Float64}` respectively (#24647).
+
+
 Command-line option changes
 ---------------------------
 

base/array.jl

@@ -384,7 +384,7 @@ For convenience `dims` may also be passed in variadic form.
 
 # Examples
 ```jldoctest
-julia> ones(Complex128, 2, 3)
+julia> ones(Complex{Float64}, 2, 3)
 2×3 Array{Complex{Float64},2}:
  1.0+0.0im  1.0+0.0im  1.0+0.0im
  1.0+0.0im  1.0+0.0im  1.0+0.0im

base/complex.jl

@@ -4,9 +4,6 @@
     Complex{T<:Real} <: Number
 
 Complex number type with real and imaginary part of type `T`.
-
-`Complex32`, `Complex64` and `Complex128` are aliases for
-`Complex{Float16}`, `Complex{Float32}` and `Complex{Float64}` respectively.
 """
 struct Complex{T<:Real} <: Number
     re::T
@@ -28,10 +25,6 @@ julia> im * im
 """
 const im = Complex(false, true)
 
-const Complex128 = Complex{Float64}
-const Complex64  = Complex{Float32}
-const Complex32  = Complex{Float16}
-
 convert(::Type{Complex{T}}, x::Real) where {T<:Real} = Complex{T}(x,0)
 convert(::Type{Complex{T}}, z::Complex) where {T<:Real} = Complex{T}(real(z),imag(z))
 convert(::Type{T}, z::Complex) where {T<:Real} =
@@ -353,7 +346,7 @@ inv(z::Complex{<:Union{Float16,Float32}}) =
 #             a + i*b
 #  p + i*q = ---------
 #             c + i*d
-function /(z::Complex128, w::Complex128)
+function /(z::Complex{Float64}, w::Complex{Float64})
     a, b = reim(z); c, d = reim(w)
     half = 0.5
     two = 2.0
@@ -369,7 +362,7 @@ function /(z::Complex128, w::Complex128)
     ab <= un*two/ϵ && (a=a*bs; b=b*bs; s=s/bs      ) # scale up a,b
     cd <= un*two/ϵ && (c=c*bs; d=d*bs; s=s*bs      ) # scale up c,d
     abs(d)<=abs(c) ? ((p,q)=robust_cdiv1(a,b,c,d)  ) : ((p,q)=robust_cdiv1(b,a,d,c); q=-q)
-    return Complex128(p*s,q*s) # undo scaling
+    return Complex{Float64}(p*s,q*s) # undo scaling
 end
 function robust_cdiv1(a::Float64, b::Float64, c::Float64, d::Float64)
     r = d/c
@@ -387,7 +380,7 @@ function robust_cdiv2(a::Float64, b::Float64, c::Float64, d::Float64, r::Float64
     end
 end
 
-function inv(w::Complex128)
+function inv(w::Complex{Float64})
     c, d = reim(w)
     half = 0.5
     two = 2.0
@@ -411,7 +404,7 @@ function inv(w::Complex128)
         p = r * t
         q = -t
     end
-    return Complex128(p*s,q*s) # undo scaling
+    return Complex{Float64}(p*s,q*s) # undo scaling
 end
 
 function ssqs(x::T, y::T) where T<:AbstractFloat

base/deprecated.jl

@@ -2097,6 +2097,11 @@ end
     @deprecate chol!(x::Number, uplo) chol(x) false
 end
 
+# #24647
+@deprecate_binding Complex32  Complex{Float16}
+@deprecate_binding Complex64  Complex{Float32}
+@deprecate_binding Complex128 Complex{Float64}
+
 # END 0.7 deprecations
 
 # BEGIN 1.0 deprecations

base/essentials.jl

@@ -351,7 +351,7 @@ Size, in bytes, of the canonical binary representation of the given DataType `T`
 julia> sizeof(Float32)
 4
 
-julia> sizeof(Complex128)
+julia> sizeof(Complex{Float64})
 16
 ```
 

base/exports.jl

@@ -44,9 +44,6 @@ export
     Cmd,
     Colon,
     Complex,
-    Complex128,
-    Complex64,
-    Complex32,
     ConjArray,
     ConjVector,
     ConjMatrix,

base/fastmath.jl

@@ -187,7 +187,7 @@ issubnormal_fast(x) = false
 
 # complex numbers
 
-ComplexTypes = Union{Complex64, Complex128}
+ComplexTypes = Union{Complex{Float32}, Complex{Float64}}
 
 @fastmath begin
     abs_fast(x::ComplexTypes) = hypot(real(x), imag(x))

base/inference.jl

@@ -2460,7 +2460,7 @@ function abstract_call(@nospecialize(f), fargs::Union{Tuple{},Vector{Any}}, argt
             length(argtypes) == 3 && (argtypes[3] ⊑ Int32 || argtypes[3] ⊑ Int64)
 
             a1 = argtypes[2]
-            basenumtype = Union{corenumtype, Main.Base.Complex64, Main.Base.Complex128, Main.Base.Rational}
+            basenumtype = Union{corenumtype, Main.Base.Complex{Float32}, Main.Base.Complex{Float64}, Main.Base.Rational}
             if a1 ⊑ basenumtype
                 ftimes = Main.Base.:*
                 ta1 = widenconst(a1)
@@ -5249,7 +5249,7 @@ function inlining_pass(e::Expr, sv::OptimizationState, stmts::Vector{Any}, ins,
             triple = (a2 === Int32(3) || a2 === Int64(3))
             if square || triple
                 a1 = e.args[2]
-                basenumtype = Union{corenumtype, Main.Base.Complex64, Main.Base.Complex128, Main.Base.Rational}
+                basenumtype = Union{corenumtype, Main.Base.Complex{Float32}, Main.Base.Complex{Float64}, Main.Base.Rational}
                 if isa(a1, basenumtype) || ((isa(a1, Symbol) || isa(a1, Slot) || isa(a1, SSAValue)) &&
                                            exprtype(a1, sv.src, sv.mod) ⊑ basenumtype)
                     if square

base/linalg/arpack.jl

@@ -255,8 +255,8 @@ for (T, saupd_name, seupd_name, naupd_name, neupd_name) in
 end
 
 for (T, TR, naupd_name, neupd_name) in
-    ((:Complex128, :Float64, :znaupd_, :zneupd_),
-     (:Complex64,  :Float32, :cnaupd_, :cneupd_))
+    ((Complex{Float64}, :Float64, :znaupd_, :zneupd_),
+     (Complex{Float32},  :Float32, :cnaupd_, :cneupd_))
     @eval begin
         function naupd(ido, bmat, n, evtype, nev, TOL::Ref{$TR}, resid::Vector{$T}, ncv, v::Matrix{$T}, ldv,
                        iparam, ipntr, workd::Vector{$T}, workl::Vector{$T}, lworkl,

base/linalg/blas.jl

@@ -65,6 +65,9 @@ const liblapack = Base.liblapack_name
 
 import ..LinAlg: BlasReal, BlasComplex, BlasFloat, BlasInt, DimensionMismatch, checksquare, axpy!
 
+const Complex64 = Complex{Float32}
+const Complex128 = Complex{Float64}
+
 # utility routines
 function vendor()
     lib = Libdl.dlopen_e(Base.libblas_name)
@@ -169,8 +172,8 @@ function blascopy! end
 
 for (fname, elty) in ((:dcopy_,:Float64),
                       (:scopy_,:Float32),
-                      (:zcopy_,:Complex128),
-                      (:ccopy_,:Complex64))
+                      (:zcopy_,Complex{Float64}),
+                      (:ccopy_,Complex{Float32}))
     @eval begin
         # SUBROUTINE DCOPY(N,DX,INCX,DY,INCY)
         function blascopy!(n::Integer, DX::Union{Ptr{$elty},StridedArray{$elty}}, incx::Integer, DY::Union{Ptr{$elty},StridedArray{$elty}}, incy::Integer)