transition linalg to Adjoint/Transpose externally

base/deprecated.jl

@@ -2990,6 +2990,131 @@ end
 # re. A_mul_B deprecation, don't forget to:
 # 1) delete function shims in base/linalg/linalg.jl
 
+# methods involving RowVector from base/linalg/bidiag.jl, to deprecate
+@eval Base.LinAlg begin
+    \(::Diagonal, ::RowVector) = _mat_ldiv_rowvec_error()
+    \(::Bidiagonal, ::RowVector) = _mat_ldiv_rowvec_error()
+    \(::Bidiagonal{<:Number}, ::RowVector{<:Number}) = _mat_ldiv_rowvec_error()
+    \(::Adjoint{<:Any,<:Bidiagonal}, ::RowVector) = _mat_ldiv_rowvec_error()
+    \(::Transpose{<:Any,<:Bidiagonal}, ::RowVector) = _mat_ldiv_rowvec_error()
+    \(::Adjoint{<:Number,<:Bidiagonal{<:Number}}, ::RowVector{<:Number}) = _mat_ldiv_rowvec_error()
+    \(::Transpose{<:Number,<:Bidiagonal{<:Number}}, ::RowVector{<:Number}) = _mat_ldiv_rowvec_error()
+    _mat_ldiv_rowvec_error() = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
+end
+
+# methods involving RowVector from base/linalg/diagonal.jl, to deprecate
+@eval Base.LinAlg begin
+    *(rowvec::RowVector, D::Diagonal) = rvtranspose(D * rvtranspose(rowvec)) # seems potentially incorrect without also transposing D?
+    *(D::Diagonal, transrowvec::Transpose{<:Any,<:RowVector}) = (rowvec = transrowvec.parent; D*rvtranspose(rowvec))
+    *(D::Diagonal, adjrowvec::Adjoint{<:Any,<:RowVector}) = (rowvec = adjrowvec.parent; D*rvadjoint(rowvec))
+end
+
+# methods involving RowVector from base/sparse/linalg.jl, to deprecate
+@eval Base.SparseArrays begin
+    \(::SparseMatrixCSC, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
+    \(::Adjoint{<:Any,<:SparseMatrixCSC}, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
+    \(::Transpose{<:Any,<:SparseMatrixCSC}, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
+end
+
+# methods involving RowVector from base/linalg/qr.jl, to deprecate
+@eval Base.LinAlg begin
+    *(rowvec::RowVector, adjB::Adjoint{<:Any,<:AbstractQ}) = (B = adjB.parent; rvadjoint(B*rvadjoint(rowvec)))
+end
+
+# methods involving RowVector from base/linalg/qr.jl, to deprecate
+@eval Base.LinAlg begin
+    *(A::RowVector, B::Adjoint{<:Any,<:AbstractRotation}) = A * adjoint(B.parent)
+end
+
+# methods involving RowVector from base/linalg/generic.jl, to deprecate
+@eval Base.LinAlg begin
+    """
+        norm(A::RowVector, q::Real=2)
+
+    For row vectors, return the ``q``-norm of `A`, which is equivalent to the p-norm with
+    value `p = q/(q-1)`. They coincide at `p = q = 2`.
+
+    The difference in norm between a vector space and its dual arises to preserve
+    the relationship between duality and the inner product, and the result is
+    consistent with the p-norm of `1 × n` matrix.
+
+    # Examples
+    ```jldoctest
+    julia> v = [1; im];
+
+    julia> vc = v';
+
+    julia> norm(vc, 1)
+    1.0
+
+    julia> norm(v, 1)
+    2.0
+
+    julia> norm(vc, 2)
+    1.4142135623730951
+
+    julia> norm(v, 2)
+    1.4142135623730951
+
+    julia> norm(vc, Inf)
+    2.0
+
+    julia> norm(v, Inf)
+    1.0
+    ```
+    """
+    norm(tv::RowVector, q::Real) = q == Inf ? norm(rvtranspose(tv), 1) : norm(rvtranspose(tv), q/(q-1))
+    norm(tv::RowVector) = norm(rvtranspose(tv))
+end
+
+# methods involving RowVector from base/linalg/factorization.jl, to deprecate
+@eval Base.LinAlg begin
+    \(A::Adjoint{<:Any,<:Factorization}, B::RowVector) = adjoint(A.parent) \ B
+    \(A::Transpose{<:Any,<:Factorization}, B::RowVector) = transpose(A.parent) \ B
+    \(A::Transpose{<:Any,<:Factorization{<:Real}}, B::RowVector) = transpose(A.parent) \ B
+end
+
+# methods involving RowVector from base/sparse/higherorderfns.jl, to deprecate
+@eval Base.SparseArrays.HigherOrderFns begin
+    BroadcastStyle(::Type{<:Base.RowVector{T,<:Vector}}) where T = Broadcast.MatrixStyle()
+end
+
+# methods involving RowVector from base/linalg/symmetric.jl, to deprecate
+@eval Base.LinAlg begin
+    *(A::RowVector, transB::Transpose{<:Any,<:RealHermSymComplexSym}) = A * transB.parent
+    *(A::RowVector, adjB::Adjoint{<:Any,<:RealHermSymComplexHerm}) = A * adjB.parent
+    \(A::HermOrSym{<:Any,<:StridedMatrix}, B::RowVector) = invoke(\, Tuple{AbstractMatrix, RowVector}, A, B)
+    *(A::Adjoint{<:Any,<:RealHermSymComplexHerm}, B::Adjoint{<:Any,<:RowVector}) = A.parent * B
+    *(A::Adjoint{<:Any,<:RealHermSymComplexHerm}, B::Transpose{<:Any,<:RowVector}) = A.parent * B
+    *(A::Transpose{<:Any,<:RealHermSymComplexSym}, B::Adjoint{<:Any,<:RowVector}) = A.parent * B
+    *(A::Transpose{<:Any,<:RealHermSymComplexSym}, B::Transpose{<:Any,<:RowVector}) = A.parent * B
+end
+
+# methods involving RowVector from base/linalg/triangular.jl, to deprecate
+@eval Base.LinAlg begin
+    *(rowvec::RowVector, A::AbstractTriangular) = rvtranspose(transpose(A) * rvtranspose(rowvec))
+    *(rowvec::RowVector, transA::Transpose{<:Any,<:AbstractTriangular}) = rvtranspose(transA.parent * rvtranspose(rowvec))
+    *(A::AbstractTriangular, transrowvec::Transpose{<:Any,<:RowVector}) = A * rvtranspose(transrowvec.parent)
+    *(transA::Transpose{<:Any,<:AbstractTriangular}, transrowvec::Transpose{<:Any,<:RowVector}) = transA.parent.' * rvtranspose(transrowvec.parent)
+    *(rowvec::RowVector, adjA::Adjoint{<:Any,<:AbstractTriangular}) = rvadjoint(adjA.parent * rvadjoint(rowvec))
+    *(A::AbstractTriangular, adjrowvec::Adjoint{<:Any,<:RowVector}) = A * rvadjoint(adjrowvec.parent)
+    *(adjA::Adjoint{<:Any,<:AbstractTriangular}, adjrowvec::Adjoint{<:Any,<:RowVector}) = adjA.parent' * rvadjoint(adjrowvec.parent)
+    \(::Union{UpperTriangular,LowerTriangular}, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
+    \(::Union{UnitUpperTriangular,UnitLowerTriangular}, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
+    \(::Adjoint{<:Any,<:Union{UpperTriangular,LowerTriangular}}, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
+    \(::Adjoint{<:Any,<:Union{UnitUpperTriangular,UnitLowerTriangular}}, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
+    \(::Transpose{<:Any,<:Union{UpperTriangular,LowerTriangular}}, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
+    \(::Transpose{<:Any,<:Union{UnitUpperTriangular,UnitLowerTriangular}}, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
+    /(rowvec::RowVector, A::Union{UpperTriangular,LowerTriangular}) = rvtranspose(transpose(A) \ rvtranspose(rowvec))
+    /(rowvec::RowVector, A::Union{UnitUpperTriangular,UnitLowerTriangular}) = rvtranspose(transpose(A) \ rvtranspose(rowvec))
+    /(rowvec::RowVector, transA::Transpose{<:Any,<:Union{UpperTriangular,LowerTriangular}}) = rvtranspose(transA.parent \ rvtranspose(rowvec))
+    /(rowvec::RowVector, transA::Transpose{<:Any,<:Union{UnitUpperTriangular,UnitLowerTriangular}}) = rvtranspose(transA.parent \ rvtranspose(rowvec))
+    /(rowvec::RowVector, adjA::Adjoint{<:Any,<:Union{UpperTriangular,LowerTriangular}}) = /(rowvec, adjoint(adjA.parent))
+    /(rowvec::RowVector, adjA::Adjoint{<:Any,<:Union{UnitUpperTriangular,UnitLowerTriangular}}) = /(rowvec, adjoint(adjA.parent))
+    *(A::Adjoint{<:Any,<:AbstractTriangular}, B::Transpose{<:Any,<:RowVector}) = A * rvtranspose(B.parent)
+    *(A::Transpose{<:Any,<:AbstractTriangular}, B::Adjoint{<:Any,<:RowVector}) = A * rvadjoint(B.parent)
+end
+
 # issue #24822
 @deprecate_binding Display AbstractDisplay
 

base/exports.jl

@@ -95,6 +95,8 @@ export
     RoundNearestTiesUp,
     RoundToZero,
     RoundUp,
+    Adjoint,
+    Transpose,
     RowVector,
     AbstractSerializer,
     SerializationState,

base/linalg/adjtrans.jl

@@ -49,12 +49,30 @@ Adjoint(x::Number) = adjoint(x)
 Transpose(x::Number) = transpose(x)
 
 # unwrapping constructors
-# perhaps slightly odd, but necessary (at least till adjoint and transpose names are free)
 Adjoint(A::Adjoint) = A.parent
 Transpose(A::Transpose) = A.parent
+# normalizing unwrapping constructors
+# technically suspect, but at least fine for now
+Adjoint(A::Transpose) = conj(A.parent)
+Transpose(A::Adjoint) = conj(A.parent)
+
+# eager lowercase quasi-constructors, unwrapping
+adjoint(A::Adjoint) = copy(A.parent)
+transpose(A::Transpose) = copy(A.parent)
+# eager lowercase quasi-constructors, normalizing
+# technically suspect, but at least fine for now
+adjoint(A::Transpose) = conj!(copy(A.parent))
+transpose(A::Adjoint) = conj!(copy(A.parent))
+
+# lowercase quasi-constructors for vectors, TODO: deprecate
+adjoint(sv::AbstractVector) = Adjoint(sv)
+transpose(sv::AbstractVector) = Transpose(sv)
+
 
 # some aliases for internal convenience use
 const AdjOrTrans{T,S} = Union{Adjoint{T,S},Transpose{T,S}} where {T,S}
+const AdjointAbsVec{T} = Adjoint{T,<:AbstractVector}
+const TransposeAbsVec{T} = Transpose{T,<:AbstractVector}
 const AdjOrTransAbsVec{T} = AdjOrTrans{T,<:AbstractVector}
 const AdjOrTransAbsMat{T} = AdjOrTrans{T,<:AbstractMatrix}
 
@@ -99,22 +117,100 @@ parent(A::AdjOrTrans) = A.parent
 vec(v::AdjOrTransAbsVec) = v.parent
 
 
+### concatenation
+# preserve Adjoint/Transpose wrapper around vectors
+# to retain the associated semantics post-concatenation
+hcat(avs::Union{Number,AdjointAbsVec}...) = _adjoint_hcat(avs...)
+hcat(tvs::Union{Number,TransposeAbsVec}...) = _transpose_hcat(tvs...)
+_adjoint_hcat(avs::Union{Number,AdjointAbsVec}...) = Adjoint(vcat(map(Adjoint, avs)...))
+_transpose_hcat(tvs::Union{Number,TransposeAbsVec}...) = Transpose(vcat(map(Transpose, tvs)...))
+typed_hcat(::Type{T}, avs::Union{Number,AdjointAbsVec}...) where {T} = Adjoint(typed_vcat(T, map(Adjoint, avs)...))
+typed_hcat(::Type{T}, tvs::Union{Number,TransposeAbsVec}...) where {T} = Transpose(typed_vcat(T, map(Transpose, tvs)...))
+# otherwise-redundant definitions necessary to prevent hitting the concat methods in sparse/sparsevector.jl
+hcat(avs::Adjoint{<:Any,<:Vector}...) = _adjoint_hcat(avs...)
+hcat(tvs::Transpose{<:Any,<:Vector}...) = _transpose_hcat(tvs...)
+hcat(avs::Adjoint{T,Vector{T}}...) where {T} = _adjoint_hcat(avs...)
+hcat(tvs::Transpose{T,Vector{T}}...) where {T} = _transpose_hcat(tvs...)
+
+
+### higher order functions
+# preserve Adjoint/Transpose wrapper around vectors
+# to retain the associated semantics post-map/broadcast
+
+# vectorfy takes an Adoint/Transpose-wrapped vector and builds
+# an unwrapped vector with the entrywise-same contents
+vectorfy(x::Number) = x
+vectorfy(adjvec::AdjointAbsVec) = map(Adjoint, adjvec.parent)
+vectorfy(transvec::TransposeAbsVec) = map(Transpose, transvec.parent)
+vectorfyall(transformedvecs...) = (map(vectorfy, transformedvecs)...,)
+
+# map over collections of Adjoint/Transpose-wrapped vectors
+# note that the caller's operation `f` should be applied to the entries of the wrapped
+# vectors, rather than the entires of the wrapped vector's parents. so first we use vectorfy
+# to build unwrapped vectors with entrywise-same contents as the wrapped input vectors.
+# then we map the caller's operation over that set of unwrapped vectors. but now re-wrapping
+# the resulting vector would inappropriately transform the result vector's entries. so
+# instead of simply mapping the caller's operation over the set of unwrapped vectors,
+# we map Adjoint/Transpose composed with the caller's operationt over the set of unwrapped
+# vectors. then re-wrapping the result vector yields a wrapped vector with the correct entries.
+map(f, avs::AdjointAbsVec...) = Adjoint(map(Adjoint∘f, vectorfyall(avs...)...))
+map(f, tvs::TransposeAbsVec...) = Transpose(map(Transpose∘f, vectorfyall(tvs...)...))
+
+# broadcast over collections of Adjoint/Transpose-wrapped vectors and numbers
+# similar explanation for these definitions as for map above
+broadcast(f, avs::Union{Number,AdjointAbsVec}...) = Adjoint(broadcast(Adjoint∘f, vectorfyall(avs...)...))
+broadcast(f, tvs::Union{Number,TransposeAbsVec}...) = Transpose(broadcast(Transpose∘f, vectorfyall(tvs...) ...))
+
+
 ### linear algebra
 
-# definitions necessary for test/linalg/rowvector.jl to pass
-# should be cleaned up / revised as necessary in the future
-/(A::Transpose{<:Any,<:Vector}, B::Matrix) = /(transpose(A.parent), B)
-/(A::Transpose{<:Any,<:Vector}, B::Transpose{<:Any,<:Matrix}) = /(transpose(A.parent), B)
-*(A::Adjoint{<:Any,<:Matrix}, B::Adjoint{<:Any,<:Vector}) = *(adjoint(A.parent), adjoint(B.parent))
+## multiplication *
+
+# Adjoint/Transpose-vector * vector
+*(u::AdjointAbsVec, v::AbstractVector) = dot(u.parent, v)
+*(u::TransposeAbsVec{T}, v::AbstractVector{T}) where {T<:Real} = dot(u.parent, v)
+function *(u::TransposeAbsVec, v::AbstractVector)
+    @boundscheck length(u) == length(v) || throw(DimensionMismatch())
+    return sum(@inbounds(return u[k]*v[k]) for k in 1:length(u))
+end
+# vector * Adjoint/Transpose-vector
+*(u::AbstractVector, v::AdjOrTransAbsVec) = broadcast(*, u, v)
+# Adjoint/Transpose-vector * Adjoint/Transpose-vector
+# (necessary for disambiguation with fallback methods in linalg/matmul)
+*(u::AdjointAbsVec, v::AdjointAbsVec) = throw(MethodError(*, (u, v)))
+*(u::TransposeAbsVec, v::TransposeAbsVec) = throw(MethodError(*, (u, v)))
+
+# Adjoint/Transpose-vector * matrix
+*(u::AdjointAbsVec, A::AbstractMatrix) = Adjoint(Adjoint(A) * u.parent)
+*(u::TransposeAbsVec, A::AbstractMatrix) = Transpose(Transpose(A) * u.parent)
+# Adjoint/Transpose-vector * Adjoint/Transpose-matrix
+*(u::AdjointAbsVec, A::Adjoint{<:Any,<:AbstractMatrix}) = Adjoint(A.parent * u.parent)
+*(u::TransposeAbsVec, A::Transpose{<:Any,<:AbstractMatrix}) = Transpose(A.parent * u.parent)
+
+
+## pseudoinversion
+pinv(v::AdjointAbsVec, tol::Real = 0) = pinv(v.parent, tol).parent
+pinv(v::TransposeAbsVec, tol::Real = 0) = pinv(conj(v.parent)).parent
+
+
+## left-division \
+\(u::AdjOrTransAbsVec, v::AdjOrTransAbsVec) = pinv(u) * v
+
+
+## right-division \
+/(u::AdjointAbsVec, A::AbstractMatrix) = Adjoint(Adjoint(A) \ u.parent)
+/(u::TransposeAbsVec, A::AbstractMatrix) = Transpose(Transpose(A) \ u.parent)
 
 
 # dismabiguation methods
-*(A::Transpose{<:Any,<:AbstractVector}, B::Adjoint{<:Any,<:AbstractVector}) = transpose(A.parent) * B
-*(A::Transpose{<:Any,<:AbstractVector}, B::Adjoint{<:Any,<:AbstractMatrix}) = transpose(A.parent) * B
-*(A::Transpose{<:Any,<:AbstractMatrix}, B::Adjoint{<:Any,<:AbstractVector}) = A * adjoint(B.parent)
+*(A::AdjointAbsVec, B::Transpose{<:Any,<:AbstractMatrix}) = A * transpose(B.parent)
+*(A::TransposeAbsVec, B::Adjoint{<:Any,<:AbstractMatrix}) = A * adjoint(B.parent)
 *(A::Transpose{<:Any,<:AbstractMatrix}, B::Adjoint{<:Any,<:AbstractMatrix}) = transpose(A.parent) * B
-*(A::Adjoint{<:Any,<:AbstractVector}, B::Transpose{<:Any,<:AbstractVector}) = adjoint(A.parent) * B
-*(A::Adjoint{<:Any,<:AbstractVector}, B::Transpose{<:Any,<:AbstractMatrix}) = adjoint(A.parent) * B
-*(A::Adjoint{<:Any,<:AbstractMatrix}, B::Adjoint{<:Any,<:AbstractVector}) = A * adjoint(B.parent)
-*(A::Adjoint{<:Any,<:AbstractMatrix}, B::Transpose{<:Any,<:AbstractVector}) = A * transpose(B.parent)
-*(A::Adjoint{<:Any,<:AbstractMatrix}, B::Transpose{<:Any,<:AbstractMatrix}) = adjoint(A.parent) * B
+*(A::Adjoint{<:Any,<:AbstractMatrix}, B::Transpose{<:Any,<:AbstractMatrix}) = A * transpose(B.parent)
+# Adj/Trans-vector * Trans/Adj-vector, shouldn't exist, here for ambiguity resolution? TODO: test removal
+*(A::Adjoint{<:Any,<:AbstractVector}, B::Transpose{<:Any,<:AbstractVector}) = throw(MethodError(*, (A, B)))
+*(A::Transpose{<:Any,<:AbstractVector}, B::Adjoint{<:Any,<:AbstractVector}) = throw(MethodError(*, (A, B)))
+# Adj/Trans-matrix * Trans/Adj-vector, shouldn't exist, here for ambiguity resolution? TODO: test removal
+*(A::Adjoint{<:Any,<:AbstractMatrix}, B::Adjoint{<:Any,<:AbstractVector}) = throw(MethodError(*, (A, B)))
+*(A::Adjoint{<:Any,<:AbstractMatrix}, B::Transpose{<:Any,<:AbstractVector}) = throw(MethodError(*, (A, B)))
+*(A::Transpose{<:Any,<:AbstractMatrix}, B::Adjoint{<:Any,<:AbstractVector}) = throw(MethodError(*, (A, B)))

base/linalg/bidiag.jl

@@ -348,15 +348,6 @@ mul!(C::AbstractMatrix, A::BiTri, B::Transpose{<:Any,<:AbstractVecOrMat}) = A_mu
 mul!(C::AbstractMatrix, A::BiTri, B::Adjoint{<:Any,<:AbstractVecOrMat}) = A_mul_B_td!(C, A, B)
 mul!(C::AbstractVector, A::BiTri, B::Transpose{<:Any,<:AbstractVecOrMat}) = throw(MethodError(mul!, (C, A, B)))
 
-\(::Diagonal, ::RowVector) = _mat_ldiv_rowvec_error()
-\(::Bidiagonal, ::RowVector) = _mat_ldiv_rowvec_error()
-\(::Bidiagonal{<:Number}, ::RowVector{<:Number}) = _mat_ldiv_rowvec_error()
-\(::Adjoint{<:Any,<:Bidiagonal}, ::RowVector) = _mat_ldiv_rowvec_error()
-\(::Transpose{<:Any,<:Bidiagonal}, ::RowVector) = _mat_ldiv_rowvec_error()
-\(::Adjoint{<:Number,<:Bidiagonal{<:Number}}, ::RowVector{<:Number}) = _mat_ldiv_rowvec_error()
-\(::Transpose{<:Number,<:Bidiagonal{<:Number}}, ::RowVector{<:Number}) = _mat_ldiv_rowvec_error()
-_mat_ldiv_rowvec_error() = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
-
 function check_A_mul_B!_sizes(C, A, B)
     nA, mA = size(A)
     nB, mB = size(B)

base/linalg/diagonal.jl

@@ -358,11 +358,6 @@ rdiv!(A::AbstractMatrix{T}, transD::Transpose{<:Any,<:Diagonal{T}}) where {T} =
 \(adjF::Adjoint{<:Any,<:Factorization}, D::Diagonal) =
     (F = adjF.parent; ldiv!(Adjoint(F), Matrix{typeof(oneunit(eltype(D))/oneunit(eltype(F)))}(D)))
 
-# Methods to resolve ambiguities with `Diagonal`
-@inline *(rowvec::RowVector, D::Diagonal) = transpose(D * transpose(rowvec))
-*(D::Diagonal, transrowvec::Transpose{<:Any,<:RowVector}) = (rowvec = transrowvec.parent; D*transpose(rowvec))
-*(D::Diagonal, adjrowvec::Adjoint{<:Any,<:RowVector}) = (rowvec = adjrowvec.parent; D*adjoint(rowvec))
-
 conj(D::Diagonal) = Diagonal(conj(D.diag))
 transpose(D::Diagonal{<:Number}) = D
 transpose(D::Diagonal) = Diagonal(transpose.(D.diag))

base/linalg/factorization.jl

@@ -85,8 +85,3 @@ ldiv!(Y::AbstractVecOrMat, transA::Transpose{<:Any,<:Factorization}, B::Abstract
 # fallback methods for transposed solves
 \(transF::Transpose{<:Any,<:Factorization{<:Real}}, B::AbstractVecOrMat) = (F = transF.parent; \(Adjoint(F), B))
 \(transF::Transpose{<:Any,<:Factorization}, B::AbstractVecOrMat) = (F = transF.parent; conj.(\(Adjoint(F), conj.(B))))
-
-# dismabiguation methods
-\(A::Adjoint{<:Any,<:Factorization}, B::RowVector) = adjoint(A.parent) \ B
-\(A::Transpose{<:Any,<:Factorization}, B::RowVector) = transpose(A.parent) \ B
-\(A::Transpose{<:Any,<:Factorization{<:Real}}, B::RowVector) = transpose(A.parent) \ B

base/linalg/generic.jl

@@ -576,13 +576,12 @@ This is equivalent to [`vecnorm`](@ref).
 """
 @inline norm(x::Number, p::Real=2) = vecnorm(x, p)
 
-@inline norm(tv::RowVector) = norm(transpose(tv))
-
 """
-    norm(A::RowVector, q::Real=2)
+    norm(A::Adjoint{<:Any,<:AbstracVector}, q::Real=2)
+    norm(A::Transpose{<:Any,<:AbstracVector}, q::Real=2)
 
-For row vectors, return the ``q``-norm of `A`, which is equivalent to the p-norm with
-value `p = q/(q-1)`. They coincide at `p = q = 2`.
+For Adjoint/Transpose-wrapped vectors, return the ``q``-norm of `A`, which is
+equivalent to the p-norm with value `p = q/(q-1)`. They coincide at `p = q = 2`.
 
 The difference in norm between a vector space and its dual arises to preserve
 the relationship between duality and the inner product, and the result is
@@ -613,7 +612,10 @@ julia> norm(v, Inf)
 1.0
 ```
 """
-@inline norm(tv::RowVector, q::Real) = q == Inf ? norm(transpose(tv), 1) : norm(transpose(tv), q/(q-1))
+norm(v::TransposeAbsVec, q::Real) = q == Inf ? norm(v.parent, 1) : norm(v.parent, q/(q-1))
+norm(v::AdjointAbsVec, q::Real) = q == Inf ? norm(conj(v.parent), 1) : norm(conj(v.parent), q/(q-1))
+norm(v::AdjointAbsVec) = norm(conj(v.parent))
+norm(v::TransposeAbsVec) = norm(v.parent)
 
 function vecdot(x::AbstractArray, y::AbstractArray)
     lx = _length(x)

base/linalg/givens.jl

@@ -379,7 +379,6 @@ end
 *(A::Transpose{<:Any,<:RealHermSymComplexSym}, B::Adjoint{<:Any,<:AbstractRotation}) = A.parent * B
 # dismabiguation methods: *(Diag/RowVec/AbsTri, Adj of AbstractRotation)
 *(A::Diagonal, B::Adjoint{<:Any,<:AbstractRotation}) = A * adjoint(B.parent)
-*(A::RowVector, B::Adjoint{<:Any,<:AbstractRotation}) = A * adjoint(B.parent)
 *(A::AbstractTriangular, B::Adjoint{<:Any,<:AbstractRotation}) = A * adjoint(B.parent)
 # moar disambiguation
 mul!(A::QRPackedQ, B::Adjoint{<:Any,<:Givens}) = throw(MethodError(mul!, (A, B)))