Rename ctranspose to adjoint (#23235)

* Rename `ctranspose` to `adjoint`

* Add PR number and missing `!`

* Remove dated commented out test

Author: andyferris

NEWS.md

@@ -318,6 +318,9 @@ Deprecated or removed
   * `Base.cpad` has been removed; use an appropriate combination of `rpad` and `lpad`
     instead ([#23187]).
 
+  * `ctranspose` and `ctranspose!` have been deprecated in favor of `adjoint` and `adjoint!`,
+    respectively ([#23235]).
+
   * `filter` and `filter!` on dictionaries now pass a single `key=>value` pair to the
     argument function, instead of two arguments ([#17886]).
 

base/deprecated.jl

@@ -1421,7 +1421,7 @@ end
 module Operators
     for op in [:!, :(!=), :(!==), :%, :&, :*, :+, :-, :/, ://, :<, :<:, :<<, :(<=),
                :<|, :(==), :(===), :>, :>:, :(>=), :>>, :>>>, :\, :^, :colon,
-               :ctranspose, :getindex, :hcat, :hvcat, :setindex!, :transpose, :vcat,
+               :adjoint, :getindex, :hcat, :hvcat, :setindex!, :transpose, :vcat,
                :xor, :|, :|>, :~, :×, :÷, :∈, :∉, :∋, :∌, :∘, :√, :∛, :∩, :∪, :≠, :≤,
                :≥, :⊆, :⊈, :⊊, :⊻, :⋅]
         if isdefined(Base, op)
@@ -1692,6 +1692,10 @@ export hex2num
 # PR #22742: change in isapprox semantics
 @deprecate rtoldefault(x,y) rtoldefault(x,y,0) false
 
+# PR #23235
+@deprecate ctranspose adjoint
+@deprecate ctranspose! adjoint!
+
 # issue #5148, PR #23259
 # warning for `const` on locals should be changed to an error in julia-syntax.scm
 

base/exports.jl

@@ -555,8 +555,8 @@ export
     cond,
     condskeel,
     cross,
-    ctranspose!,
-    ctranspose,
+    adjoint!,
+    adjoint,
     det,
     diag,
     diagind,

base/linalg/bidiag.jl

@@ -223,7 +223,7 @@ broadcast(::typeof(floor), ::Type{T}, M::Bidiagonal) where {T<:Integer} = Bidiag
 broadcast(::typeof(ceil), ::Type{T}, M::Bidiagonal) where {T<:Integer} = Bidiagonal(ceil.(T, M.dv), ceil.(T, M.ev), M.uplo)
 
 transpose(M::Bidiagonal) = Bidiagonal(M.dv, M.ev, M.uplo == 'U' ? :L : :U)
-ctranspose(M::Bidiagonal) = Bidiagonal(conj(M.dv), conj(M.ev), M.uplo == 'U' ? :L : :U)
+adjoint(M::Bidiagonal) = Bidiagonal(conj(M.dv), conj(M.ev), M.uplo == 'U' ? :L : :U)
 
 istriu(M::Bidiagonal) = M.uplo == 'U' || iszero(M.ev)
 istril(M::Bidiagonal) = M.uplo == 'L' || iszero(M.ev)
@@ -458,7 +458,7 @@ end
 #Linear solvers
 A_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, b::AbstractVector) = naivesub!(A, b)
 At_ldiv_B!(A::Bidiagonal, b::AbstractVector) = A_ldiv_B!(transpose(A), b)
-Ac_ldiv_B!(A::Bidiagonal, b::AbstractVector) = A_ldiv_B!(ctranspose(A), b)
+Ac_ldiv_B!(A::Bidiagonal, b::AbstractVector) = A_ldiv_B!(adjoint(A), b)
 function A_ldiv_B!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix)
     nA,mA = size(A)
     tmp = similar(B,size(B,1))

base/linalg/bitarray.jl

@@ -295,4 +295,4 @@ function transpose(B::BitMatrix)
     return Bt
 end
 
-ctranspose(B::Union{BitMatrix,BitVector}) = transpose(B)
+adjoint(B::Union{BitMatrix,BitVector}) = transpose(B)

base/linalg/cholesky.jl

@@ -150,7 +150,7 @@ function chol(A::RealHermSymComplexHerm)
     if A.uplo == 'U'
         copy!(AA, A.data)
     else
-        Base.ctranspose!(AA, A.data)
+        Base.adjoint!(AA, A.data)
     end
     chol!(Hermitian(AA, :U))
 end

base/linalg/conjarray.jl

@@ -5,7 +5,7 @@
 
 A lazy-view wrapper of an `AbstractArray`, taking the elementwise complex conjugate. This
 type is usually constructed (and unwrapped) via the [`conj`](@ref) function (or related
-[`ctranspose`](@ref)), but currently this is the default behavior for `RowVector` only. For
+[`adjoint`](@ref)), but currently this is the default behavior for `RowVector` only. For
 other arrays, the `ConjArray` constructor can be used directly.
 
 # Examples

base/linalg/diagonal.jl

@@ -186,11 +186,11 @@ function A_mul_B!(D::Diagonal, B::UnitUpperTriangular)
     UpperTriangular(B.data)
 end
 
-Ac_mul_B(D::Diagonal, B::Diagonal) = Diagonal(ctranspose.(D.diag) .* B.diag)
-Ac_mul_B(A::AbstractTriangular, D::Diagonal) = A_mul_B!(ctranspose(A), D)
+Ac_mul_B(D::Diagonal, B::Diagonal) = Diagonal(adjoint.(D.diag) .* B.diag)
+Ac_mul_B(A::AbstractTriangular, D::Diagonal) = A_mul_B!(adjoint(A), D)
 function Ac_mul_B(A::AbstractMatrix, D::Diagonal)
     Ac = similar(A, promote_op(*, eltype(A), eltype(D.diag)), (size(A, 2), size(A, 1)))
-    ctranspose!(Ac, A)
+    adjoint!(Ac, A)
     A_mul_B!(Ac, D)
 end
 
@@ -202,12 +202,12 @@ function At_mul_B(A::AbstractMatrix, D::Diagonal)
     A_mul_B!(At, D)
 end
 
-A_mul_Bc(D::Diagonal, B::Diagonal) = Diagonal(D.diag .* ctranspose.(B.diag))
-A_mul_Bc(D::Diagonal, B::AbstractTriangular) = A_mul_B!(D, ctranspose(B))
+A_mul_Bc(D::Diagonal, B::Diagonal) = Diagonal(D.diag .* adjoint.(B.diag))
+A_mul_Bc(D::Diagonal, B::AbstractTriangular) = A_mul_B!(D, adjoint(B))
 A_mul_Bc(D::Diagonal, Q::Union{Base.LinAlg.QRCompactWYQ,Base.LinAlg.QRPackedQ}) = A_mul_Bc!(Array(D), Q)
 function A_mul_Bc(D::Diagonal, A::AbstractMatrix)
     Ac = similar(A, promote_op(*, eltype(A), eltype(D.diag)), (size(A, 2), size(A, 1)))
-    ctranspose!(Ac, A)
+    adjoint!(Ac, A)
     A_mul_B!(D, Ac)
 end
 
@@ -219,7 +219,7 @@ function A_mul_Bt(D::Diagonal, A::AbstractMatrix)
     A_mul_B!(D, At)
 end
 
-Ac_mul_Bc(D::Diagonal, B::Diagonal) = Diagonal(ctranspose.(D.diag) .* ctranspose.(B.diag))
+Ac_mul_Bc(D::Diagonal, B::Diagonal) = Diagonal(adjoint.(D.diag) .* adjoint.(B.diag))
 At_mul_Bt(D::Diagonal, B::Diagonal) = Diagonal(transpose.(D.diag) .* transpose.(B.diag))
 
 A_mul_B!(A::Diagonal,B::Diagonal)  = throw(MethodError(A_mul_B!, Tuple{Diagonal,Diagonal}))
@@ -235,11 +235,11 @@ A_mul_Bc!(A::AbstractMatrix,B::Diagonal) = scale!(A,conj(B.diag))
 
 # Get ambiguous method if try to unify AbstractVector/AbstractMatrix here using AbstractVecOrMat
 A_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) = out .= A.diag .* in
-Ac_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) = out .= ctranspose.(A.diag) .* in
+Ac_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) = out .= adjoint.(A.diag) .* in
 At_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) = out .= transpose.(A.diag) .* in
 
 A_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) = out .= A.diag .* in
-Ac_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) = out .= ctranspose.(A.diag) .* in
+Ac_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) = out .= adjoint.(A.diag) .* in
 At_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) = out .= transpose.(A.diag) .* in
 
 # ambiguities with Symmetric/Hermitian
@@ -306,13 +306,13 @@ A_rdiv_Bt!(A::AbstractMatrix{T}, D::Diagonal{T}) where {T} = A_rdiv_B!(A, D)
 # Methods to resolve ambiguities with `Diagonal`
 @inline *(rowvec::RowVector, D::Diagonal) = transpose(D * transpose(rowvec))
 @inline A_mul_Bt(D::Diagonal, rowvec::RowVector) = D*transpose(rowvec)
-@inline A_mul_Bc(D::Diagonal, rowvec::RowVector) = D*ctranspose(rowvec)
+@inline A_mul_Bc(D::Diagonal, rowvec::RowVector) = D*adjoint(rowvec)
 
 conj(D::Diagonal) = Diagonal(conj(D.diag))
 transpose(D::Diagonal{<:Number}) = D
 transpose(D::Diagonal) = Diagonal(transpose.(D.diag))
-ctranspose(D::Diagonal{<:Number}) = conj(D)
-ctranspose(D::Diagonal) = Diagonal(ctranspose.(D.diag))
+adjoint(D::Diagonal{<:Number}) = conj(D)
+adjoint(D::Diagonal) = Diagonal(adjoint.(D.diag))
 
 diag(D::Diagonal) = D.diag
 trace(D::Diagonal) = sum(D.diag)

base/linalg/factorization.jl

@@ -6,7 +6,7 @@ abstract type Factorization{T} end
 
 eltype(::Type{Factorization{T}}) where {T} = T
 transpose(F::Factorization) = error("transpose not implemented for $(typeof(F))")
-ctranspose(F::Factorization) = error("ctranspose not implemented for $(typeof(F))")
+adjoint(F::Factorization) = error("adjoint not implemented for $(typeof(F))")
 
 macro assertposdef(A, info)
    :($(esc(info)) == 0 ? $(esc(A)) : throw(PosDefException($(esc(info)))))

base/linalg/generic.jl

@@ -942,7 +942,7 @@ function ishermitian(A::AbstractMatrix)
         return false
     end
     for i = indsn, j = i:last(indsn)
-        if A[i,j] != ctranspose(A[j,i])
+        if A[i,j] != adjoint(A[j,i])
             return false
         end
     end