From d83dca96f8f66469d6b9e5232a34844e1e3c65db Mon Sep 17 00:00:00 2001 From: Sacha Verweij Date: Tue, 19 Dec 2017 15:16:20 -0800 Subject: [PATCH 1/3] Deprecate A[ct]_(mul|ldiv|rdiv)_B[ct][!] in favor f *, /, \, mul!, ldiv!, and rdiv!. --- base/deprecated.jl | 1214 ++++++++++++++---------------- base/exports.jl | 28 - base/linalg/linalg.jl | 92 +-- base/sparse/sparse.jl | 5 +- doc/src/manual/linear-algebra.md | 8 +- doc/src/stdlib/linalg.md | 33 +- 6 files changed, 591 insertions(+), 789 deletions(-) diff --git a/base/deprecated.jl b/base/deprecated.jl index e9692dc7851ae..e6ed62f8b1b67 100644 --- a/base/deprecated.jl +++ b/base/deprecated.jl @@ -2248,448 +2248,486 @@ finalizer(f::Ptr{Cvoid}, o::Function) = invoke(finalizer, Tuple{Ptr{Cvoid}, Any} Base.@deprecate_binding broadcast_t broadcast false ", broadcast_t(f, ::Type{ElType}, shape, iter, As...)` should become `broadcast(f, Broadcast.DefaultArrayStyle{N}(), ElType, shape, As...))` (see the manual chapter Interfaces)" end +# A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/operators.jl, to deprecate +@deprecate Ac_ldiv_Bt(a,b) (\)(Adjoint(a), Transpose(b)) +@deprecate At_ldiv_Bt(a,b) (\)(Transpose(a), Transpose(b)) +@deprecate A_ldiv_Bt(a,b) (\)(a, Transpose(b)) +@deprecate At_ldiv_B(a,b) (\)(Transpose(a), b) +@deprecate Ac_ldiv_Bc(a,b) (\)(Adjoint(a), Adjoint(b)) +@deprecate A_ldiv_Bc(a,b) (\)(a, Adjoint(b)) +@deprecate Ac_ldiv_B(a,b) (\)(Adjoint(a), b) +@deprecate At_rdiv_Bt(a,b) (/)(Transpose(a), Transpose(b)) +@deprecate A_rdiv_Bt(a,b) (/)(a, Transpose(b)) +@deprecate At_rdiv_B(a,b) (/)(Transpose(a), b) +@deprecate Ac_rdiv_Bc(a,b) (/)(Adjoint(a), Adjoint(b)) +@deprecate A_rdiv_Bc(a,b) (/)(a, Adjoint(b)) +@deprecate Ac_rdiv_B(a,b) (/)(Adjoint(a), b) +@deprecate At_mul_Bt(a,b) (*)(Transpose(a), Transpose(b)) +@deprecate A_mul_Bt(a,b) (*)(a, Transpose(b)) +@deprecate At_mul_B(a,b) (*)(Transpose(a), b) +@deprecate Ac_mul_Bc(a,b) (*)(Adjoint(a), Adjoint(b)) +@deprecate A_mul_Bc(a,b) (*)(a, Adjoint(b)) +@deprecate Ac_mul_B(a,b) (*)(Adjoint(a), b) +# additionally, the following in-place ops were exported from Base +export A_mul_B!, + A_mul_Bt!, At_mul_B!, At_mul_Bt!, + A_mul_Bc!, Ac_mul_B!, Ac_mul_Bc!, + A_ldiv_B!, At_ldiv_B!, Ac_ldiv_B! + +# operations formerly exported from and imported/extended by Base.LinAlg +@eval Base.LinAlg begin + import Base: A_mul_Bt, At_ldiv_Bt, A_rdiv_Bc, At_ldiv_B, Ac_mul_Bc, A_mul_Bc, Ac_mul_B, + Ac_ldiv_B, Ac_ldiv_Bc, At_mul_Bt, A_rdiv_Bt, At_mul_B + # most of these explicit exports are of course obviated by the deprecations below + # but life is easier just leaving them for now... + export A_ldiv_B!, + A_ldiv_Bc, + A_ldiv_Bt, + A_mul_B!, + A_mul_Bc, + A_mul_Bc!, + A_mul_Bt, + A_mul_Bt!, + A_rdiv_Bc, + A_rdiv_Bt, + Ac_ldiv_B, + Ac_ldiv_Bc, + Ac_ldiv_B!, + Ac_mul_B, + Ac_mul_B!, + Ac_mul_Bc, + Ac_mul_Bc!, + Ac_rdiv_B, + Ac_rdiv_Bc, + At_ldiv_B, + At_ldiv_Bt, + At_ldiv_B!, + At_mul_B, + At_mul_B!, + At_mul_Bt, + At_mul_Bt!, + At_rdiv_B, + At_rdiv_Bt +end + # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/bidiag.jl, to deprecate @eval Base.LinAlg begin - A_mul_B!(C::AbstractMatrix, A::SymTridiagonal, B::BiTriSym) = mul!(C, A, B) - A_mul_B!(C::AbstractMatrix, A::BiTri, B::BiTriSym) = mul!(C, A, B) - A_mul_B!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym) = mul!(C, A, B) - A_mul_B!(C::AbstractMatrix, A::AbstractTriangular, B::BiTriSym) = mul!(C, A, B) - A_mul_B!(C::AbstractMatrix, A::AbstractMatrix, B::BiTriSym) = mul!(C, A, B) - A_mul_B!(C::AbstractMatrix, A::Diagonal, B::BiTriSym) = mul!(C, A, B) - A_mul_B!(C::AbstractVector, A::BiTri, B::AbstractVector) = mul!(C, A, B) - A_mul_B!(C::AbstractMatrix, A::BiTri, B::AbstractVecOrMat) = mul!(C, A, B) - A_mul_B!(C::AbstractVecOrMat, A::BiTri, B::AbstractVecOrMat) = mul!(C, A, B) - Ac_ldiv_B(A::Bidiagonal, v::RowVector) = \(Adjoint(A), v) - At_ldiv_B(A::Bidiagonal, v::RowVector) = \(Transpose(A), v) - Ac_ldiv_B(A::Bidiagonal{<:Number}, v::RowVector{<:Number}) = \(Adjoint(A), v) - At_ldiv_B(A::Bidiagonal{<:Number}, v::RowVector{<:Number}) = \(Transpose(A), v) - Ac_mul_B(A::Bidiagonal{T}, B::AbstractVector{T}) where {T} = *(Adjoint(A), B) - A_mul_Bc(A::Bidiagonal{T}, B::AbstractVector{T}) where {T} = *(A, Adjoint(B)) - A_rdiv_Bc(A::Bidiagonal{T}, B::AbstractVector{T}) where {T} = /(A, Adjoint(B)) - A_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, b::AbstractVector) = ldiv!(A, b) - At_ldiv_B!(A::Bidiagonal, b::AbstractVector) = ldiv!(Transpose(A), b) - Ac_ldiv_B!(A::Bidiagonal, b::AbstractVector) = ldiv!(Adjoint(A), b) - A_ldiv_B!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix) = ldiv!(A, B) - Ac_ldiv_B!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix) = ldiv!(Adjoint(A), B) - At_ldiv_B!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix) = ldiv!(Transpose(A), B) - At_ldiv_B(A::Bidiagonal{TA}, B::AbstractVecOrMat{TB}) where {TA<:Number,TB<:Number} = \(Transpose(A), B) - At_ldiv_B(A::Bidiagonal, B::AbstractVecOrMat) = \(Transpose(A), B) - Ac_ldiv_B(A::Bidiagonal{TA}, B::AbstractVecOrMat{TB}) where {TA<:Number,TB<:Number} = \(Adjoint(A), B) - Ac_ldiv_B(A::Bidiagonal, B::AbstractVecOrMat) = ldiv!(Adjoint(A), B) + @deprecate A_mul_B!(C::AbstractMatrix, A::SymTridiagonal, B::BiTriSym) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractMatrix, A::BiTri, B::BiTriSym) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractMatrix, A::AbstractTriangular, B::BiTriSym) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractMatrix, A::AbstractMatrix, B::BiTriSym) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractMatrix, A::Diagonal, B::BiTriSym) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractVector, A::BiTri, B::AbstractVector) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractMatrix, A::BiTri, B::AbstractVecOrMat) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractVecOrMat, A::BiTri, B::AbstractVecOrMat) mul!(C, A, B) + @deprecate Ac_ldiv_B(A::Bidiagonal, v::RowVector) (\)(Adjoint(A), v) + @deprecate At_ldiv_B(A::Bidiagonal, v::RowVector) (\)(Transpose(A), v) + @deprecate Ac_ldiv_B(A::Bidiagonal{<:Number}, v::RowVector{<:Number}) (\)(Adjoint(A), v) + @deprecate At_ldiv_B(A::Bidiagonal{<:Number}, v::RowVector{<:Number}) (\)(Transpose(A), v) + @deprecate Ac_mul_B(A::Bidiagonal{T}, B::AbstractVector{T}) where {T} (*)(Adjoint(A), B) + @deprecate A_mul_Bc(A::Bidiagonal{T}, B::AbstractVector{T}) where {T} (*)(A, Adjoint(B)) + @deprecate A_rdiv_Bc(A::Bidiagonal{T}, B::AbstractVector{T}) where {T} (/)(A, Adjoint(B)) + @deprecate A_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, b::AbstractVector) ldiv!(A, b) + @deprecate At_ldiv_B!(A::Bidiagonal, b::AbstractVector) ldiv!(Transpose(A), b) + @deprecate Ac_ldiv_B!(A::Bidiagonal, b::AbstractVector) ldiv!(Adjoint(A), b) + @deprecate A_ldiv_B!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix) ldiv!(A, B) + @deprecate Ac_ldiv_B!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix) ldiv!(Adjoint(A), B) + @deprecate At_ldiv_B!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix) ldiv!(Transpose(A), B) + @deprecate At_ldiv_B(A::Bidiagonal, B::AbstractVecOrMat) (\)(Transpose(A), B) + @deprecate Ac_ldiv_B(A::Bidiagonal, B::AbstractVecOrMat) ldiv!(Adjoint(A), B) + @deprecate Ac_ldiv_B(A::Bidiagonal{TA}, B::AbstractVecOrMat{TB}) where {TA<:Number,TB<:Number} (\)(Adjoint(A), B) + @deprecate At_ldiv_B(A::Bidiagonal{TA}, B::AbstractVecOrMat{TB}) where {TA<:Number,TB<:Number} (\)(Transpose(A), B) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/tridiag.jl, to deprecate @eval Base.LinAlg begin - A_mul_B!(C::StridedVecOrMat, S::SymTridiagonal, B::StridedVecOrMat) = mul!(C, S, B) + @deprecate A_mul_B!(C::StridedVecOrMat, S::SymTridiagonal, B::StridedVecOrMat) mul!(C, S, B) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/diagonal.jl, to deprecate @eval Base.LinAlg begin - A_mul_B!(A::Union{LowerTriangular,UpperTriangular}, D::Diagonal) = mul!(A, D) - A_mul_B!(A::UnitLowerTriangular, D::Diagonal) = mul!(A, D) - A_mul_B!(A::UnitUpperTriangular, D::Diagonal) = mul!(A, D) - A_mul_B!(D::Diagonal, B::UnitLowerTriangular) = mul!(D, B) - A_mul_B!(D::Diagonal, B::UnitUpperTriangular) = mul!(D, B) - Ac_mul_B(D::Diagonal, B::Diagonal) = *(Adjoint(D), B) - Ac_mul_B(A::AbstractTriangular, D::Diagonal) = *(Adjoint(A), D) - Ac_mul_B(A::AbstractMatrix, D::Diagonal) = *(Adjoint(A), D) - At_mul_B(D::Diagonal, B::Diagonal) = *(Transpose(D), B) - At_mul_B(A::AbstractTriangular, D::Diagonal) = *(Transpose(A), D) - At_mul_B(A::AbstractMatrix, D::Diagonal) = *(Transpose(A), D) - A_mul_Bc(D::Diagonal, B::Diagonal) = *(D, Adjoint(B)) - A_mul_Bc(D::Diagonal, B::AbstractTriangular) = *(D, Adjoint(B)) - A_mul_Bc(D::Diagonal, Q::Union{QRCompactWYQ,QRPackedQ}) = *(D, Adjoint(Q)) - A_mul_Bc(D::Diagonal, A::AbstractMatrix) = *(D, Adjoint(A)) - A_mul_Bt(D::Diagonal, B::Diagonal) = *(D, Transpose(B)) - A_mul_Bt(D::Diagonal, B::AbstractTriangular) = *(D, Transpose(B)) - A_mul_Bt(D::Diagonal, A::AbstractMatrix) = *(D, Transpose(A)) - Ac_mul_Bc(D::Diagonal, B::Diagonal) = *(Adjoint(D), Adjoint(B)) - At_mul_Bt(D::Diagonal, B::Diagonal) = *(Transpose(D), Transpose(B)) - A_mul_B!(A::Diagonal,B::Diagonal) = mul!(A, B) - At_mul_B!(A::Diagonal,B::Diagonal) = mul!(Transpose(A), B) - Ac_mul_B!(A::Diagonal,B::Diagonal) = mul!(Adjoint(A), B) - A_mul_B!(A::QRPackedQ, D::Diagonal) = mul!(A, D) - A_mul_B!(A::Diagonal,B::AbstractMatrix) = mul!(A, B) - At_mul_B!(A::Diagonal,B::AbstractMatrix) = mul!(Transpose(A), B) - Ac_mul_B!(A::Diagonal,B::AbstractMatrix) = mul!(Adjoint(A), B) - A_mul_B!(A::AbstractMatrix,B::Diagonal) = mul!(A, B) - A_mul_Bt!(A::AbstractMatrix,B::Diagonal) = mul!(A, Transpose(B)) - A_mul_Bc!(A::AbstractMatrix,B::Diagonal) = mul!(A, Adjoint(B)) - A_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) = mul!(out, A, in) - Ac_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) = mul!(out, Adjoint(A), in) - At_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) = mul!(out, Transpose(A), in) - A_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) = mul!(out, A, in) - Ac_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) = mul!(out, Adjoint(A), in) - At_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) = mul!(out, Transpose(A), in) - A_mul_Bt(A::Diagonal, B::RealHermSymComplexSym) = *(A, Transpose(B)) - At_mul_B(A::RealHermSymComplexSym, B::Diagonal) = *(Transpose(A), B) - A_mul_Bc(A::Diagonal, B::RealHermSymComplexHerm) = *(A, Adjoint(B)) - Ac_mul_B(A::RealHermSymComplexHerm, B::Diagonal) = *(Adjoint(A), B) - A_ldiv_B!(D::Diagonal{T}, v::AbstractVector{T}) where {T} = ldiv!(D, v) - A_ldiv_B!(D::Diagonal{T}, V::AbstractMatrix{T}) where {T} = ldiv!(D, V) - Ac_ldiv_B!(D::Diagonal{T}, B::AbstractVecOrMat{T}) where {T} = ldiv!(Adjoint(D), B) - At_ldiv_B!(D::Diagonal{T}, B::AbstractVecOrMat{T}) where {T} = ldiv!(Transpose(D), B) - A_rdiv_B!(A::AbstractMatrix{T}, D::Diagonal{T}) where {T} = rdiv!(A, D) - A_rdiv_Bc!(A::AbstractMatrix{T}, D::Diagonal{T}) where {T} = rdiv!(A, Adjoint(D)) - A_rdiv_Bt!(A::AbstractMatrix{T}, D::Diagonal{T}) where {T} = rdiv!(A, Transpose(D)) - Ac_ldiv_B(F::Factorization, D::Diagonal) = \(Adjoint(F), D) - A_mul_Bt(D::Diagonal, rowvec::RowVector) = *(D, Transpose(rowvec)) - A_mul_Bc(D::Diagonal, rowvec::RowVector) = *(D, Adjoint(rowvec)) - A_ldiv_B!(D::Diagonal, B::StridedVecOrMat) = ldiv!(D, B) + @deprecate A_mul_B!(A::Union{LowerTriangular,UpperTriangular}, D::Diagonal) mul!(A, D) + @deprecate A_mul_B!(A::UnitLowerTriangular, D::Diagonal) mul!(A, D) + @deprecate A_mul_B!(A::UnitUpperTriangular, D::Diagonal) mul!(A, D) + @deprecate A_mul_B!(D::Diagonal, B::UnitLowerTriangular) mul!(D, B) + @deprecate A_mul_B!(D::Diagonal, B::UnitUpperTriangular) mul!(D, B) + @deprecate Ac_mul_B(D::Diagonal, B::Diagonal) (*)(Adjoint(D), B) + @deprecate Ac_mul_B(A::AbstractTriangular, D::Diagonal) (*)(Adjoint(A), D) + @deprecate Ac_mul_B(A::AbstractMatrix, D::Diagonal) (*)(Adjoint(A), D) + @deprecate At_mul_B(D::Diagonal, B::Diagonal) (*)(Transpose(D), B) + @deprecate At_mul_B(A::AbstractTriangular, D::Diagonal) (*)(Transpose(A), D) + @deprecate At_mul_B(A::AbstractMatrix, D::Diagonal) (*)(Transpose(A), D) + @deprecate A_mul_Bc(D::Diagonal, B::Diagonal) (*)(D, Adjoint(B)) + @deprecate A_mul_Bc(D::Diagonal, B::AbstractTriangular) (*)(D, Adjoint(B)) + @deprecate A_mul_Bc(D::Diagonal, Q::Union{QRCompactWYQ,QRPackedQ}) (*)(D, Adjoint(Q)) + @deprecate A_mul_Bc(D::Diagonal, A::AbstractMatrix) (*)(D, Adjoint(A)) + @deprecate A_mul_Bt(D::Diagonal, B::Diagonal) (*)(D, Transpose(B)) + @deprecate A_mul_Bt(D::Diagonal, B::AbstractTriangular) (*)(D, Transpose(B)) + @deprecate A_mul_Bt(D::Diagonal, A::AbstractMatrix) (*)(D, Transpose(A)) + @deprecate Ac_mul_Bc(D::Diagonal, B::Diagonal) (*)(Adjoint(D), Adjoint(B)) + @deprecate At_mul_Bt(D::Diagonal, B::Diagonal) (*)(Transpose(D), Transpose(B)) + @deprecate A_mul_B!(A::Diagonal,B::Diagonal) mul!(A, B) + @deprecate At_mul_B!(A::Diagonal,B::Diagonal) mul!(Transpose(A), B) + @deprecate Ac_mul_B!(A::Diagonal,B::Diagonal) mul!(Adjoint(A), B) + @deprecate A_mul_B!(A::QRPackedQ, D::Diagonal) mul!(A, D) + @deprecate A_mul_B!(A::Diagonal,B::AbstractMatrix) mul!(A, B) + @deprecate At_mul_B!(A::Diagonal,B::AbstractMatrix) mul!(Transpose(A), B) + @deprecate Ac_mul_B!(A::Diagonal,B::AbstractMatrix) mul!(Adjoint(A), B) + @deprecate A_mul_B!(A::AbstractMatrix,B::Diagonal) mul!(A, B) + @deprecate A_mul_Bt!(A::AbstractMatrix,B::Diagonal) mul!(A, Transpose(B)) + @deprecate A_mul_Bc!(A::AbstractMatrix,B::Diagonal) mul!(A, Adjoint(B)) + @deprecate A_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) mul!(out, A, in) + @deprecate Ac_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) mul!(out, Adjoint(A), in) + @deprecate At_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) mul!(out, Transpose(A), in) + @deprecate A_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) mul!(out, A, in) + @deprecate Ac_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) mul!(out, Adjoint(A), in) + @deprecate At_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) mul!(out, Transpose(A), in) + @deprecate A_mul_Bt(A::Diagonal, B::RealHermSymComplexSym) (*)(A, Transpose(B)) + @deprecate At_mul_B(A::RealHermSymComplexSym, B::Diagonal) (*)(Transpose(A), B) + @deprecate A_mul_Bc(A::Diagonal, B::RealHermSymComplexHerm) (*)(A, Adjoint(B)) + @deprecate Ac_mul_B(A::RealHermSymComplexHerm, B::Diagonal) (*)(Adjoint(A), B) + @deprecate A_ldiv_B!(D::Diagonal{T}, v::AbstractVector{T}) where {T} ldiv!(D, v) + @deprecate A_ldiv_B!(D::Diagonal{T}, V::AbstractMatrix{T}) where {T} ldiv!(D, V) + @deprecate Ac_ldiv_B!(D::Diagonal{T}, B::AbstractVecOrMat{T}) where {T} ldiv!(Adjoint(D), B) + @deprecate At_ldiv_B!(D::Diagonal{T}, B::AbstractVecOrMat{T}) where {T} ldiv!(Transpose(D), B) + @deprecate A_rdiv_B!(A::AbstractMatrix{T}, D::Diagonal{T}) where {T} rdiv!(A, D) + @deprecate A_rdiv_Bc!(A::AbstractMatrix{T}, D::Diagonal{T}) where {T} rdiv!(A, Adjoint(D)) + @deprecate A_rdiv_Bt!(A::AbstractMatrix{T}, D::Diagonal{T}) where {T} rdiv!(A, Transpose(D)) + @deprecate Ac_ldiv_B(F::Factorization, D::Diagonal) (\)(Adjoint(F), D) + @deprecate A_mul_Bt(D::Diagonal, rowvec::RowVector) (*)(D, Transpose(rowvec)) + @deprecate A_mul_Bc(D::Diagonal, rowvec::RowVector) (*)(D, Adjoint(rowvec)) + @deprecate A_ldiv_B!(D::Diagonal, B::StridedVecOrMat) ldiv!(D, B) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/special.jl, to deprecate @eval Base.LinAlg begin - A_mul_Bc!(A::AbstractTriangular, B::Union{QRCompactWYQ,QRPackedQ}) = mul!(A, Adjoint(B)) - A_mul_Bc(A::AbstractTriangular, B::Union{QRCompactWYQ,QRPackedQ}) = *(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::AbstractTriangular, B::Union{QRCompactWYQ,QRPackedQ}) mul!(A, Adjoint(B)) + @deprecate A_mul_Bc(A::AbstractTriangular, B::Union{QRCompactWYQ,QRPackedQ}) (*)(A, Adjoint(B)) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/bunchkaufman.jl, to deprecate @eval Base.LinAlg begin - A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where {T<:BlasReal} = ldiv!(B, R) - A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where {T<:BlasComplex} = ldiv!(B, R) - A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{S}) where {T,S} = ldiv!(B, R) + @deprecate A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where {T<:BlasReal} ldiv!(B, R) + @deprecate A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where {T<:BlasComplex} ldiv!(B, R) + @deprecate A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{S}) where {T,S} ldiv!(B, R) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/cholesky.jl, to deprecate @eval Base.LinAlg begin - A_ldiv_B!(C::Cholesky{T,<:AbstractMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = ldiv!(C, B) - A_ldiv_B!(C::Cholesky{<:Any,<:AbstractMatrix}, B::StridedVecOrMat) = ldiv!(C, B) - A_ldiv_B!(C::CholeskyPivoted{T}, B::StridedVector{T}) where {T<:BlasFloat} = ldiv!(C, B) - A_ldiv_B!(C::CholeskyPivoted{T}, B::StridedMatrix{T}) where {T<:BlasFloat} = ldiv!(C, B) - A_ldiv_B!(C::CholeskyPivoted, B::StridedVector) = ldiv!(C, B) - A_ldiv_B!(C::CholeskyPivoted, B::StridedMatrix) = ldiv!(C, B) + @deprecate A_ldiv_B!(C::Cholesky{T,<:AbstractMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} ldiv!(C, B) + @deprecate A_ldiv_B!(C::Cholesky{<:Any,<:AbstractMatrix}, B::StridedVecOrMat) ldiv!(C, B) + @deprecate A_ldiv_B!(C::CholeskyPivoted{T}, B::StridedVector{T}) where {T<:BlasFloat} ldiv!(C, B) + @deprecate A_ldiv_B!(C::CholeskyPivoted{T}, B::StridedMatrix{T}) where {T<:BlasFloat} ldiv!(C, B) + @deprecate A_ldiv_B!(C::CholeskyPivoted, B::StridedVector) ldiv!(C, B) + @deprecate A_ldiv_B!(C::CholeskyPivoted, B::StridedMatrix) ldiv!(C, B) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/factorization.jl, to deprecate @eval Base.LinAlg begin - Ac_ldiv_B(F::Factorization, B::AbstractVecOrMat) = \(Adjoint(F), B) - A_ldiv_B!(Y::AbstractVecOrMat, A::Factorization, B::AbstractVecOrMat) = ldiv!(Y, A, B) - Ac_ldiv_B!(Y::AbstractVecOrMat, A::Factorization, B::AbstractVecOrMat) = ldiv!(Y, Adjoint(A), B) - At_ldiv_B!(Y::AbstractVecOrMat, A::Factorization, B::AbstractVecOrMat) = ldiv!(Y, Transpose(A), B) - At_ldiv_B(F::Factorization{<:Real}, B::AbstractVecOrMat) = \(Transpose(F), B) - At_ldiv_B(F::Factorization, B) = \(Transpose(F), B) + @deprecate Ac_ldiv_B(F::Factorization, B::AbstractVecOrMat) (\)(Adjoint(F), B) + @deprecate A_ldiv_B!(Y::AbstractVecOrMat, A::Factorization, B::AbstractVecOrMat) ldiv!(Y, A, B) + @deprecate Ac_ldiv_B!(Y::AbstractVecOrMat, A::Factorization, B::AbstractVecOrMat) ldiv!(Y, Adjoint(A), B) + @deprecate At_ldiv_B!(Y::AbstractVecOrMat, A::Factorization, B::AbstractVecOrMat) ldiv!(Y, Transpose(A), B) + @deprecate At_ldiv_B(F::Factorization{<:Real}, B::AbstractVecOrMat) (\)(Transpose(F), B) + @deprecate At_ldiv_B(F::Factorization, B) (\)(Transpose(F), B) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/hessenberg.jl, to deprecate @eval Base.LinAlg begin - A_mul_B!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} = mul!(Q, X) - A_mul_B!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} = mul!(X, Q) - Ac_mul_B!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} = mul!(Adjoint(Q), X) - A_mul_Bc!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} = mul!(X, Adjoint(Q)) - Ac_mul_B(Q::HessenbergQ{T}, X::StridedVecOrMat{S}) where {T,S} = *(Adjoint(Q), X) - A_mul_Bc(X::StridedVecOrMat{S}, Q::HessenbergQ{T}) where {T,S} = *(X, Adjoint(Q)) + @deprecate A_mul_B!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} mul!(Q, X) + @deprecate A_mul_B!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} mul!(X, Q) + @deprecate Ac_mul_B!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} mul!(Adjoint(Q), X) + @deprecate A_mul_Bc!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} mul!(X, Adjoint(Q)) + @deprecate Ac_mul_B(Q::HessenbergQ{T}, X::StridedVecOrMat{S}) where {T,S} (*)(Adjoint(Q), X) + @deprecate A_mul_Bc(X::StridedVecOrMat{S}, Q::HessenbergQ{T}) where {T,S} (*)(X, Adjoint(Q)) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/ldlt.jl, to deprecate @eval Base.LinAlg begin - A_ldiv_B!(S::LDLt{T,M}, B::AbstractVecOrMat{T}) where {T,M<:SymTridiagonal{T}} = ldiv!(S, B) + @deprecate A_ldiv_B!(S::LDLt{T,M}, B::AbstractVecOrMat{T}) where {T,M<:SymTridiagonal{T}} ldiv!(S, B) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/svd.jl, to deprecate @eval Base.LinAlg begin - A_ldiv_B!(A::SVD{T}, B::StridedVecOrMat) where {T} = ldiv!(A, B) + @deprecate A_ldiv_B!(A::SVD{T}, B::StridedVecOrMat) where {T} ldiv!(A, B) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/symmetric.jl, to deprecate @eval Base.LinAlg begin - A_mul_B!(y::StridedVector{T}, A::Symmetric{T,<:StridedMatrix}, x::StridedVector{T}) where {T<:BlasFloat} = mul!(y, A, x) - A_mul_B!(y::StridedVector{T}, A::Hermitian{T,<:StridedMatrix}, x::StridedVector{T}) where {T<:BlasReal} = mul!(y, A, x) - A_mul_B!(y::StridedVector{T}, A::Hermitian{T,<:StridedMatrix}, x::StridedVector{T}) where {T<:BlasComplex} = mul!(y, A, x) - A_mul_B!(C::StridedMatrix{T}, A::Symmetric{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} = mul!(C, A, B) - A_mul_B!(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Symmetric{T,<:StridedMatrix}) where {T<:BlasFloat} = mul!(C, A, B) - A_mul_B!(C::StridedMatrix{T}, A::Hermitian{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasReal} = mul!(C, A, B) - A_mul_B!(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Hermitian{T,<:StridedMatrix}) where {T<:BlasReal} = mul!(C, A, B) - A_mul_B!(C::StridedMatrix{T}, A::Hermitian{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasComplex} = mul!(C, A, B) - A_mul_B!(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Hermitian{T,<:StridedMatrix}) where {T<:BlasComplex} = mul!(C, A, B) - At_mul_B(A::RealHermSymComplexSym, B::AbstractVector) = *(Transpose(A), B) - At_mul_B(A::RealHermSymComplexSym, B::AbstractMatrix) = *(Transpose(A), B) - A_mul_Bt(A::AbstractMatrix, B::RealHermSymComplexSym) = *(A, Transpose(B)) - Ac_mul_B(A::RealHermSymComplexHerm, B::AbstractVector) = *(Adjoint(A), B) - Ac_mul_B(A::RealHermSymComplexHerm, B::AbstractMatrix) = *(Adjoint(A), B) - A_mul_Bc(A::AbstractMatrix, B::RealHermSymComplexHerm) = *(A, Adjoint(B)) - A_mul_Bt(A::RowVector, B::RealHermSymComplexSym) = *(A, Transpose(B)) - A_mul_Bc(A::RowVector, B::RealHermSymComplexHerm) = *(A, Adjoint(B)) - At_mul_B(A::RealHermSymComplexSym, B::AbstractTriangular) = *(Transpose(A), B) - A_mul_Bt(A::AbstractTriangular, B::RealHermSymComplexSym) = *(A, Transpose(B)) - Ac_mul_B(A::RealHermSymComplexHerm, B::AbstractTriangular) = *(Adjoint(A), B) - A_mul_Bc(A::AbstractTriangular, B::RealHermSymComplexHerm) = *(A, Adjoint(B)) + @deprecate A_mul_B!(y::StridedVector{T}, A::Symmetric{T,<:StridedMatrix}, x::StridedVector{T}) where {T<:BlasFloat} mul!(y, A, x) + @deprecate A_mul_B!(y::StridedVector{T}, A::Hermitian{T,<:StridedMatrix}, x::StridedVector{T}) where {T<:BlasReal} mul!(y, A, x) + @deprecate A_mul_B!(y::StridedVector{T}, A::Hermitian{T,<:StridedMatrix}, x::StridedVector{T}) where {T<:BlasComplex} mul!(y, A, x) + @deprecate A_mul_B!(C::StridedMatrix{T}, A::Symmetric{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} mul!(C, A, B) + @deprecate A_mul_B!(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Symmetric{T,<:StridedMatrix}) where {T<:BlasFloat} mul!(C, A, B) + @deprecate A_mul_B!(C::StridedMatrix{T}, A::Hermitian{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasReal} mul!(C, A, B) + @deprecate A_mul_B!(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Hermitian{T,<:StridedMatrix}) where {T<:BlasReal} mul!(C, A, B) + @deprecate A_mul_B!(C::StridedMatrix{T}, A::Hermitian{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasComplex} mul!(C, A, B) + @deprecate A_mul_B!(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Hermitian{T,<:StridedMatrix}) where {T<:BlasComplex} mul!(C, A, B) + @deprecate At_mul_B(A::RealHermSymComplexSym, B::AbstractVector) (*)(Transpose(A), B) + @deprecate At_mul_B(A::RealHermSymComplexSym, B::AbstractMatrix) (*)(Transpose(A), B) + @deprecate A_mul_Bt(A::AbstractMatrix, B::RealHermSymComplexSym) (*)(A, Transpose(B)) + @deprecate Ac_mul_B(A::RealHermSymComplexHerm, B::AbstractVector) (*)(Adjoint(A), B) + @deprecate Ac_mul_B(A::RealHermSymComplexHerm, B::AbstractMatrix) (*)(Adjoint(A), B) + @deprecate A_mul_Bc(A::AbstractMatrix, B::RealHermSymComplexHerm) (*)(A, Adjoint(B)) + @deprecate A_mul_Bt(A::RowVector, B::RealHermSymComplexSym) (*)(A, Transpose(B)) + @deprecate A_mul_Bc(A::RowVector, B::RealHermSymComplexHerm) (*)(A, Adjoint(B)) + @deprecate At_mul_B(A::RealHermSymComplexSym, B::AbstractTriangular) (*)(Transpose(A), B) + @deprecate A_mul_Bt(A::AbstractTriangular, B::RealHermSymComplexSym) (*)(A, Transpose(B)) + @deprecate Ac_mul_B(A::RealHermSymComplexHerm, B::AbstractTriangular) (*)(Adjoint(A), B) + @deprecate A_mul_Bc(A::AbstractTriangular, B::RealHermSymComplexHerm) (*)(A, Adjoint(B)) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/lu.jl, to deprecate @eval Base.LinAlg begin - A_ldiv_B!(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = ldiv!(A, B) - A_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedVecOrMat) = ldiv!(A, B) - At_ldiv_B!(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = ldiv!(Transpose(A), B) - At_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedVecOrMat) = ldiv!(Transpose(A), B) - Ac_ldiv_B!(F::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:Real} = ldiv!(Adjoint(F), B) - Ac_ldiv_B!(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = ldiv!(Adjoint(A), B) - Ac_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedVecOrMat) = ldiv!(Adjoint(A), B) - At_ldiv_Bt(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = \(Transpose(A), Transpose(B)) - At_ldiv_Bt(A::LU, B::StridedVecOrMat) = \(Transpose(A), Transpose(B)) - Ac_ldiv_Bc(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = \(Adjoint(A), Adjoint(B)) - Ac_ldiv_Bc(A::LU, B::StridedVecOrMat) = \(Adjoint(A), Adjoint(B)) - A_ldiv_B!(A::LU{T,Tridiagonal{T,V}}, B::AbstractVecOrMat) where {T,V} = ldiv!(A, B) - At_ldiv_B!(A::LU{T,Tridiagonal{T,V}}, B::AbstractVecOrMat) where {T,V} = \(Transpose(A), B) - Ac_ldiv_B!(A::LU{T,Tridiagonal{T,V}}, B::AbstractVecOrMat) where {T,V} = ldiv!(Adjoint(A), B) + @deprecate A_ldiv_B!(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} ldiv!(A, B) + @deprecate A_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedVecOrMat) ldiv!(A, B) + @deprecate At_ldiv_B!(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} ldiv!(Transpose(A), B) + @deprecate At_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedVecOrMat) ldiv!(Transpose(A), B) + @deprecate Ac_ldiv_B!(F::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:Real} ldiv!(Adjoint(F), B) + @deprecate Ac_ldiv_B!(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasComplex} ldiv!(Adjoint(A), B) + @deprecate Ac_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedVecOrMat) ldiv!(Adjoint(A), B) + @deprecate At_ldiv_Bt(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} (\)(Transpose(A), Transpose(B)) + @deprecate At_ldiv_Bt(A::LU, B::StridedVecOrMat) (\)(Transpose(A), Transpose(B)) + @deprecate Ac_ldiv_Bc(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasComplex} (\)(Adjoint(A), Adjoint(B)) + @deprecate Ac_ldiv_Bc(A::LU, B::StridedVecOrMat) (\)(Adjoint(A), Adjoint(B)) + @deprecate A_ldiv_B!(A::LU{T,Tridiagonal{T,V}}, B::AbstractVecOrMat) where {T,V} ldiv!(A, B) + @deprecate At_ldiv_B!(A::LU{T,Tridiagonal{T,V}}, B::AbstractVecOrMat) where {T,V} (\)(Transpose(A), B) + @deprecate Ac_ldiv_B!(A::LU{T,Tridiagonal{T,V}}, B::AbstractVecOrMat) where {T,V} ldiv!(Adjoint(A), B) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/lq.jl, to deprecate @eval Base.LinAlg begin - A_mul_B!(A::LQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = mul!(A, B) - A_mul_B!(A::LQ{T}, B::QR{T}) where {T<:BlasFloat} = mul!(A, B) - A_mul_B!(A::QR{T}, B::LQ{T}) where {T<:BlasFloat} = mul!(A, B) - A_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = mul!(A, B) - Ac_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasReal} = mul!(Adjoint(A), B) - Ac_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = mul!(Adjoint(A), B) - Ac_mul_B(A::LQPackedQ, B::StridedVecOrMat) = *(Adjoint(A), B) - A_mul_Bc(A::LQPackedQ, B::StridedVecOrMat) = *(A, Adjoint(B)) - Ac_mul_Bc(A::LQPackedQ, B::StridedVecOrMat) = *(Adjoint(A), Adjoint(B)) - A_mul_B!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasFloat} = mul!(A, B) - A_mul_Bc!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasReal} = mul!(A, Adjoint(B)) - A_mul_Bc!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasComplex} = mul!(A, Adjoint(B)) - A_mul_Bc(A::StridedVecOrMat, Q::LQPackedQ) = *(A, Adjoint(Q)) - Ac_mul_Bc(A::StridedMatrix, Q::LQPackedQ) = *(Adjoint(A), Adjoint(Q)) - Ac_mul_B(A::StridedMatrix, Q::LQPackedQ) = *(Adjoint(A), Q) - A_ldiv_B!(A::LQ{T}, B::StridedVecOrMat{T}) where {T} = ldiv!(A, B) + @deprecate A_mul_B!(A::LQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} mul!(A, B) + @deprecate A_mul_B!(A::LQ{T}, B::QR{T}) where {T<:BlasFloat} mul!(A, B) + @deprecate A_mul_B!(A::QR{T}, B::LQ{T}) where {T<:BlasFloat} mul!(A, B) + @deprecate A_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} mul!(A, B) + @deprecate Ac_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasReal} mul!(Adjoint(A), B) + @deprecate Ac_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} mul!(Adjoint(A), B) + @deprecate Ac_mul_B(A::LQPackedQ, B::StridedVecOrMat) (*)(Adjoint(A), B) + @deprecate A_mul_Bc(A::LQPackedQ, B::StridedVecOrMat) (*)(A, Adjoint(B)) + @deprecate Ac_mul_Bc(A::LQPackedQ, B::StridedVecOrMat) (*)(Adjoint(A), Adjoint(B)) + @deprecate A_mul_B!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasFloat} mul!(A, B) + @deprecate A_mul_Bc!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasReal} mul!(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasComplex} mul!(A, Adjoint(B)) + @deprecate A_mul_Bc(A::StridedVecOrMat, Q::LQPackedQ) (*)(A, Adjoint(Q)) + @deprecate Ac_mul_Bc(A::StridedMatrix, Q::LQPackedQ) (*)(Adjoint(A), Adjoint(Q)) + @deprecate Ac_mul_B(A::StridedMatrix, Q::LQPackedQ) (*)(Adjoint(A), Q) + @deprecate A_ldiv_B!(A::LQ{T}, B::StridedVecOrMat{T}) where {T} ldiv!(A, B) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/qr.jl, to deprecate @eval Base.LinAlg begin - A_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} = mul!(A, B) - A_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} = mul!(A, B) - A_mul_B!(A::QRPackedQ, B::AbstractVecOrMat) = mul!(A, B) - Ac_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} = mul!(Adjoint(A), B) - Ac_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} = mul!(Adjoint(A), B) - Ac_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} = mul!(Adjoint(A), B) - Ac_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} = mul!(Adjoint(A), B) - Ac_mul_B!(A::QRPackedQ, B::AbstractVecOrMat) = mul!(Adjoint(A), B) - Ac_mul_B(Q::AbstractQ, B::StridedVecOrMat) = *(Adjoint(Q), B) - A_mul_Bc(Q::AbstractQ, B::StridedVecOrMat) = *(Q, Adjoint(B)) - Ac_mul_Bc(Q::AbstractQ, B::StridedVecOrMat) = *(Adjoint(Q), Adjoint(B)) - A_mul_B!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} = mul!(A, B) - A_mul_B!(A::StridedVecOrMat{T}, B::QRPackedQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} = mul!(A, B) - A_mul_B!(A::StridedMatrix,Q::QRPackedQ) = mul!(A, Q) - A_mul_Bc!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) where {T<:BlasReal} = mul!(A, Adjoint(B)) - A_mul_Bc!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) where {T<:BlasComplex} = mul!(A, Adjoint(B)) - A_mul_Bc!(A::StridedVecOrMat{T}, B::QRPackedQ{T}) where {T<:BlasReal} = mul!(A, Adjoint(B)) - A_mul_Bc!(A::StridedVecOrMat{T}, B::QRPackedQ{T}) where {T<:BlasComplex} = mul!(A, Adjoint(B)) - A_mul_Bc!(A::StridedMatrix,Q::QRPackedQ) = mul!(A, Adjoint(Q)) - A_mul_Bc(A::StridedMatrix, B::AbstractQ) = *(A, Adjoint(B)) - A_mul_Bc(rowvec::RowVector, B::AbstractQ) = *(rowvec, Adjoint(B)) - Ac_mul_B(A::StridedVecOrMat, Q::AbstractQ) = *(Adjoint(A), Q) - Ac_mul_Bc(A::StridedVecOrMat, Q::AbstractQ) = *(Adjoint(A), Adjoint(Q)) - A_ldiv_B!(A::QRCompactWY{T}, b::StridedVector{T}) where {T<:BlasFloat} = ldiv!(A, b) - A_ldiv_B!(A::QRCompactWY{T}, B::StridedMatrix{T}) where {T<:BlasFloat} = ldiv!(A, B) - A_ldiv_B!(A::QRPivoted{T}, B::StridedMatrix{T}, rcond::Real) where {T<:BlasFloat} = ldiv!(A, B, rcond) - A_ldiv_B!(A::QRPivoted{T}, B::StridedVector{T}) where {T<:BlasFloat} = ldiv!(A, B) - A_ldiv_B!(A::QRPivoted{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = ldiv!(A, B) - A_ldiv_B!(A::QR{T}, B::StridedMatrix{T}) where {T} = ldiv!(A, B) - A_ldiv_B!(A::QR, B::StridedVector) = ldiv!(A, B) - A_ldiv_B!(A::QRPivoted, b::StridedVector) = ldiv!(A, b) - A_ldiv_B!(A::QRPivoted, B::StridedMatrix) = ldiv!(A, B) + @deprecate A_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} mul!(A, B) + @deprecate A_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} mul!(A, B) + @deprecate A_mul_B!(A::QRPackedQ, B::AbstractVecOrMat) mul!(A, B) + @deprecate Ac_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} mul!(Adjoint(A), B) + @deprecate Ac_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} mul!(Adjoint(A), B) + @deprecate Ac_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} mul!(Adjoint(A), B) + @deprecate Ac_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} mul!(Adjoint(A), B) + @deprecate Ac_mul_B!(A::QRPackedQ, B::AbstractVecOrMat) mul!(Adjoint(A), B) + @deprecate Ac_mul_B(Q::AbstractQ, B::StridedVecOrMat) (*)(Adjoint(Q), B) + @deprecate A_mul_Bc(Q::AbstractQ, B::StridedVecOrMat) (*)(Q, Adjoint(B)) + @deprecate Ac_mul_Bc(Q::AbstractQ, B::StridedVecOrMat) (*)(Adjoint(Q), Adjoint(B)) + @deprecate A_mul_B!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} mul!(A, B) + @deprecate A_mul_B!(A::StridedVecOrMat{T}, B::QRPackedQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} mul!(A, B) + @deprecate A_mul_B!(A::StridedMatrix,Q::QRPackedQ) mul!(A, Q) + @deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) where {T<:BlasReal} mul!(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) where {T<:BlasComplex} mul!(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRPackedQ{T}) where {T<:BlasReal} mul!(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRPackedQ{T}) where {T<:BlasComplex} mul!(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::StridedMatrix,Q::QRPackedQ) mul!(A, Adjoint(Q)) + @deprecate A_mul_Bc(A::StridedMatrix, B::AbstractQ) (*)(A, Adjoint(B)) + @deprecate A_mul_Bc(rowvec::RowVector, B::AbstractQ) (*)(rowvec, Adjoint(B)) + @deprecate Ac_mul_B(A::StridedVecOrMat, Q::AbstractQ) (*)(Adjoint(A), Q) + @deprecate Ac_mul_Bc(A::StridedVecOrMat, Q::AbstractQ) (*)(Adjoint(A), Adjoint(Q)) + @deprecate A_ldiv_B!(A::QRCompactWY{T}, b::StridedVector{T}) where {T<:BlasFloat} ldiv!(A, b) + @deprecate A_ldiv_B!(A::QRCompactWY{T}, B::StridedMatrix{T}) where {T<:BlasFloat} ldiv!(A, B) + @deprecate A_ldiv_B!(A::QRPivoted{T}, B::StridedMatrix{T}, rcond::Real) where {T<:BlasFloat} ldiv!(A, B, rcond) + @deprecate A_ldiv_B!(A::QRPivoted{T}, B::StridedVector{T}) where {T<:BlasFloat} ldiv!(A, B) + @deprecate A_ldiv_B!(A::QRPivoted{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} ldiv!(A, B) + @deprecate A_ldiv_B!(A::QR{T}, B::StridedMatrix{T}) where {T} ldiv!(A, B) + @deprecate A_ldiv_B!(A::QR, B::StridedVector) ldiv!(A, B) + @deprecate A_ldiv_B!(A::QRPivoted, b::StridedVector) ldiv!(A, b) + @deprecate A_ldiv_B!(A::QRPivoted, B::StridedMatrix) ldiv!(A, B) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/matmul.jl, to deprecate @eval Base.LinAlg begin - Ac_mul_Bc(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} = *(Adjoint(A), Adjoint(B)) - Ac_mul_Bc!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = mul!(C, Adjoint(A), Adjoint(B)) - Ac_mul_Bc!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = mul!(C, Adjoint(A), Adjoint(B)) - Ac_mul_Bt!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = mul!(C, Adjoint(A), Transpose(B)) - A_mul_Bc!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = mul!(C, A, Adjoint(B)) - A_mul_Bc!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = mul!(C, A, Adjoint(B)) - A_mul_Bc(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} = *(A, Adjoint(B)) - A_mul_Bc(A::StridedMatrix{<:BlasFloat}, B::StridedMatrix{<:BlasReal}) = *(A, Adjoint(B)) - A_mul_Bc!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{<:BlasReal}) where {T<:BlasFloat} = mul!(C, A, Adjoint(B)) - Ac_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = mul!(C, Adjoint(A), B) - Ac_mul_B!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = mul!(C, Adjoint(A), B) - Ac_mul_B(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} = *(Adjoint(A), B) - Ac_mul_B(A::StridedMatrix{T}, B::StridedMatrix{T}) where {T<:BlasReal} = *(Adjoint(A), B) - Ac_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasReal} = mul!(C, Adjoint(A), B) - At_mul_Bt!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = mul!(C, Transpose(A), Transpose(B)) - At_mul_Bt!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = mul!(C, Transpose(A), Transpose(B)) - At_mul_Bt(A::AbstractMatrix{T}, B::AbstractVecOrMat{S}) where {T,S} = *(Transpose(A), Transpose(B)) - A_mul_Bt!(C::AbstractVecOrMat, A::AbstractVecOrMat, B::AbstractVecOrMat) = mul!(C, A, Transpose(B)) - A_mul_Bt!(C::StridedMatrix{Complex{Float32}}, A::StridedVecOrMat{Complex{Float32}}, B::StridedVecOrMat{Float32}) = mul!(C, A, Transpose(B)) - A_mul_Bt!(C::StridedMatrix{Complex{Float64}}, A::StridedVecOrMat{Complex{Float64}}, B::StridedVecOrMat{Float64}) = mul!(C, A, Transpose(B)) - A_mul_Bt!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = mul!(C, A, Transpose(B)) - A_mul_Bt(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} = *(A, Transpose(B)) - At_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = mul!(C, Transpose(A), B) - At_mul_B!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = mul!(C, Transpose(A), B) - At_mul_B(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} = *(Transpose(A), B) - """ - A_mul_B!(A, B) - - Calculate the matrix-matrix product ``AB``, overwriting one of `A` or `B` (but not both), - and return the result (the overwritten argument). - """ - A_mul_B!(A, B) - """ - A_mul_B!(Y, A, B) -> Y - - Calculates the matrix-matrix or matrix-vector product ``AB`` and stores the result in `Y`, - overwriting the existing value of `Y`. Note that `Y` must not be aliased with either `A` or - `B`. - - # Examples - ```jldoctest - julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; Y = similar(B); A_mul_B!(Y, A, B); - - julia> Y - 2×2 Array{Float64,2}: - 3.0 3.0 - 7.0 7.0 - ``` - """ - A_mul_B!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = mul!(C, A, B) - A_mul_B!(C::StridedMatrix{Complex{Float32}}, A::StridedVecOrMat{Complex{Float32}}, B::StridedVecOrMat{Float32}) = mul!(C, A, B) - A_mul_B!(C::StridedMatrix{Complex{Float64}}, A::StridedVecOrMat{Complex{Float64}}, B::StridedVecOrMat{Float64}) = mul!(C, A, B) - A_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = mul!(C, A, B) - Ac_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasReal} = mul!(y, Adjoint(A), x) - Ac_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasComplex} = mul!(y, Adjoint(A), x) - Ac_mul_B!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector) = mul!(y, Adjoint(A), x) - Ac_mul_B(A::StridedMatrix{T}, x::StridedVector{S}) where {T<:BlasFloat,S} = *(Adjoint(A), x) - Ac_mul_B(A::AbstractMatrix{T}, x::AbstractVector{S}) where {T,S} = *(Adjoint(A), x) - At_mul_B(A::StridedMatrix{T}, x::StridedVector{S}) where {T<:BlasFloat,S} = *(Transpose(A), x) - At_mul_B(A::AbstractMatrix{T}, x::AbstractVector{S}) where {T,S} = *(Transpose(A), x) - At_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasFloat} = mul!(y, Transpose(A), x) - At_mul_B!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector) = mul!(y, Transpose(A), x) - A_mul_B!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector) = mul!(y, A, x) - A_mul_B!(y::StridedVector{Complex{Float32}}, A::StridedVecOrMat{Complex{Float32}}, x::StridedVector{Float32}) = mul!(y, A, x) - A_mul_B!(y::StridedVector{Complex{Float64}}, A::StridedVecOrMat{Complex{Float64}}, x::StridedVector{Float64}) = mul!(y, A, x) - A_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasFloat} = mul!(y, A, x) - A_mul_Bt(a::AbstractVector, B::AbstractMatrix) = *(a, Transpose(B)) - A_mul_Bt(A::AbstractMatrix, b::AbstractVector) = *(A, Transpose(b)) - A_mul_Bc(a::AbstractVector, B::AbstractMatrix) = *(a, Adjoint(B)) - A_mul_Bc(A::AbstractMatrix, b::AbstractVector) = *(A, Adjoint(b)) - At_mul_B(x::StridedVector{T}, y::StridedVector{T}) where {T<:BlasComplex} = *(Transpose(x), y) + @deprecate Ac_mul_Bc(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} (*)(Adjoint(A), Adjoint(B)) + @deprecate Ac_mul_Bc!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} mul!(C, Adjoint(A), Adjoint(B)) + @deprecate Ac_mul_Bc!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) mul!(C, Adjoint(A), Adjoint(B)) + @deprecate Ac_mul_Bt!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) mul!(C, Adjoint(A), Transpose(B)) + @deprecate A_mul_Bc!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} mul!(C, A, Adjoint(B)) + @deprecate A_mul_Bc!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) mul!(C, A, Adjoint(B)) + @deprecate A_mul_Bc(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} (*)(A, Adjoint(B)) + @deprecate A_mul_Bc(A::StridedMatrix{<:BlasFloat}, B::StridedMatrix{<:BlasReal}) (*)(A, Adjoint(B)) + @deprecate A_mul_Bc!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{<:BlasReal}) where {T<:BlasFloat} mul!(C, A, Adjoint(B)) + @deprecate Ac_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} mul!(C, Adjoint(A), B) + @deprecate Ac_mul_B!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) mul!(C, Adjoint(A), B) + @deprecate Ac_mul_B(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} (*)(Adjoint(A), B) + @deprecate Ac_mul_B(A::StridedMatrix{T}, B::StridedMatrix{T}) where {T<:BlasReal} (*)(Adjoint(A), B) + @deprecate Ac_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasReal} mul!(C, Adjoint(A), B) + @deprecate At_mul_Bt!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} mul!(C, Transpose(A), Transpose(B)) + @deprecate At_mul_Bt!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) mul!(C, Transpose(A), Transpose(B)) + @deprecate At_mul_Bt(A::AbstractMatrix{T}, B::AbstractVecOrMat{S}) where {T,S} (*)(Transpose(A), Transpose(B)) + @deprecate A_mul_Bt!(C::AbstractVecOrMat, A::AbstractVecOrMat, B::AbstractVecOrMat) mul!(C, A, Transpose(B)) + @deprecate A_mul_Bt!(C::StridedMatrix{Complex{Float32}}, A::StridedVecOrMat{Complex{Float32}}, B::StridedVecOrMat{Float32}) mul!(C, A, Transpose(B)) + @deprecate A_mul_Bt!(C::StridedMatrix{Complex{Float64}}, A::StridedVecOrMat{Complex{Float64}}, B::StridedVecOrMat{Float64}) mul!(C, A, Transpose(B)) + @deprecate A_mul_Bt!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} mul!(C, A, Transpose(B)) + @deprecate A_mul_Bt(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} (*)(A, Transpose(B)) + @deprecate At_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} mul!(C, Transpose(A), B) + @deprecate At_mul_B!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) mul!(C, Transpose(A), B) + @deprecate At_mul_B(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} (*)(Transpose(A), B) + @deprecate A_mul_B!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) mul!(C, A, B) + @deprecate A_mul_B!(C::StridedMatrix{Complex{Float32}}, A::StridedVecOrMat{Complex{Float32}}, B::StridedVecOrMat{Float32}) mul!(C, A, B) + @deprecate A_mul_B!(C::StridedMatrix{Complex{Float64}}, A::StridedVecOrMat{Complex{Float64}}, B::StridedVecOrMat{Float64}) mul!(C, A, B) + @deprecate A_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} mul!(C, A, B) + @deprecate Ac_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasReal} mul!(y, Adjoint(A), x) + @deprecate Ac_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasComplex} mul!(y, Adjoint(A), x) + @deprecate Ac_mul_B!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector) mul!(y, Adjoint(A), x) + @deprecate Ac_mul_B(A::StridedMatrix{T}, x::StridedVector{S}) where {T<:BlasFloat,S} (*)(Adjoint(A), x) + @deprecate Ac_mul_B(A::AbstractMatrix{T}, x::AbstractVector{S}) where {T,S} (*)(Adjoint(A), x) + @deprecate At_mul_B(A::StridedMatrix{T}, x::StridedVector{S}) where {T<:BlasFloat,S} (*)(Transpose(A), x) + @deprecate At_mul_B(A::AbstractMatrix{T}, x::AbstractVector{S}) where {T,S} (*)(Transpose(A), x) + @deprecate At_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasFloat} mul!(y, Transpose(A), x) + @deprecate At_mul_B!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector) mul!(y, Transpose(A), x) + @deprecate A_mul_B!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector) mul!(y, A, x) + @deprecate A_mul_B!(y::StridedVector{Complex{Float32}}, A::StridedVecOrMat{Complex{Float32}}, x::StridedVector{Float32}) mul!(y, A, x) + @deprecate A_mul_B!(y::StridedVector{Complex{Float64}}, A::StridedVecOrMat{Complex{Float64}}, x::StridedVector{Float64}) mul!(y, A, x) + @deprecate A_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasFloat} mul!(y, A, x) + @deprecate A_mul_Bt(a::AbstractVector, B::AbstractMatrix) (*)(a, Transpose(B)) + @deprecate A_mul_Bt(A::AbstractMatrix, b::AbstractVector) (*)(A, Transpose(b)) + @deprecate A_mul_Bc(a::AbstractVector, B::AbstractMatrix) (*)(a, Adjoint(B)) + @deprecate A_mul_Bc(A::AbstractMatrix, b::AbstractVector) (*)(A, Adjoint(b)) + @deprecate At_mul_B(x::StridedVector{T}, y::StridedVector{T}) where {T<:BlasComplex} (*)(Transpose(x), y) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/triangular.jl, to deprecate @eval Base.LinAlg begin - A_mul_Bc(A::AbstractTriangular, B::AbstractTriangular) = *(A, Adjoint(B)) - A_mul_Bt(A::AbstractTriangular, B::AbstractTriangular) = *(A, Transpose(B)) - Ac_mul_B(A::AbstractTriangular, B::AbstractTriangular) = *(Adjoint(A), B) - At_mul_B(A::AbstractTriangular, B::AbstractTriangular) = *(Transpose(A), B) - Ac_ldiv_B(A::Union{UpperTriangular,LowerTriangular}, B::RowVector) = \(Adjoint(A), B) - Ac_ldiv_B(A::Union{UnitUpperTriangular,UnitLowerTriangular}, B::RowVector) = \(Adjoint(A), B) - At_ldiv_B(A::Union{UpperTriangular,LowerTriangular}, B::RowVector) = \(Transpose(A), B) - At_ldiv_B(A::Union{UnitUpperTriangular,UnitLowerTriangular}, B::RowVector) = \(Transpose(A), B) - A_rdiv_Bc(rowvec::RowVector, A::Union{UpperTriangular,LowerTriangular}) = /(rowvec, Adjoint(A)) - A_rdiv_Bc(rowvec::RowVector, A::Union{UnitUpperTriangular,UnitLowerTriangular}) = /(rowvec, Adjoint(A)) - A_rdiv_Bt(rowvec::RowVector, A::Union{UpperTriangular,LowerTriangular}) = /(rowvec, Transpose(A)) - A_rdiv_Bt(rowvec::RowVector, A::Union{UnitUpperTriangular,UnitLowerTriangular}) = /(rowvec, Transpose(A)) - A_mul_Bt(rowvec::RowVector, A::AbstractTriangular) = *(rowvec, Transpose(A)) - A_mul_Bt(A::AbstractTriangular, rowvec::RowVector) = *(A, Transpose(rowvec)) - At_mul_Bt(A::AbstractTriangular, rowvec::RowVector) = *(Transpose(A), Transpose(rowvec)) - A_mul_Bc(rowvec::RowVector, A::AbstractTriangular) = *(rowvec, Adjoint(A)) - A_mul_Bc(A::AbstractTriangular, rowvec::RowVector) = *(A, Adjoint(rowvec)) - Ac_mul_Bc(A::AbstractTriangular, rowvec::RowVector) = *(Adjoint(A), Adjoint(rowvec)) - Ac_mul_B(A::AbstractMatrix, B::AbstractTriangular) = *(Adjoint(A), B) - At_mul_B(A::AbstractMatrix, B::AbstractTriangular) = *(Transpose(A), B) - A_mul_Bc(A::AbstractTriangular, B::AbstractMatrix) = *(A, Adjoint(B)) - A_mul_Bt(A::AbstractTriangular, B::AbstractMatrix) = *(A, Transpose(B)) - Ac_mul_Bc(A::AbstractTriangular, B::AbstractTriangular) = *(Adjoint(A), Adjoint(B)) - Ac_mul_Bc(A::AbstractTriangular, B::AbstractMatrix) = *(Adjoint(A), Adjoint(B)) - Ac_mul_Bc(A::AbstractMatrix, B::AbstractTriangular) = *(Adjoint(A), Adjoint(B)) - At_mul_Bt(A::AbstractTriangular, B::AbstractTriangular) = *(Transpose(A), Transpose(B)) - At_mul_Bt(A::AbstractTriangular, B::AbstractMatrix) = *(Transpose(A), Transpose(B)) - At_mul_Bt(A::AbstractMatrix, B::AbstractTriangular) = *(Transpose(A), Transpose(B)) - A_mul_Bc!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) = mul!(A, Adjoint(B)) - A_mul_Bc!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) = mul!(A, Adjoint(B)) - A_mul_Bt!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) = mul!(A, Transpose(B)) - A_mul_Bt!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) = mul!(A, Transpose(B)) - A_rdiv_Bc!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) = rdiv!(A, Adjoint(B)) - A_rdiv_Bc!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) = rdiv!(A, Adjoint(B)) - A_rdiv_Bt!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) = rdiv!(A, Transpose(B)) - A_rdiv_Bt!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) = rdiv!(A, Transpose(B)) - A_rdiv_B!(A::UpperTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) = rdiv!(A, B) - A_rdiv_B!(A::LowerTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) = rdiv!(A, B) - Ac_mul_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) = mul!(Adjoint(A), B) - Ac_mul_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) = mul!(Adjoint(A), B) - At_mul_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) = mul!(Transpose(A), B) - At_mul_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) = mul!(Transpose(A), B) - Ac_ldiv_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) = ldiv!(Adjoint(A), B) - Ac_ldiv_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) = ldiv!(Adjoint(A), B) - At_ldiv_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) = ldiv!(Transpose(A), B) - At_ldiv_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) = ldiv!(Transpose(A), B) - A_rdiv_Bt!(A::StridedMatrix, B::UnitLowerTriangular) = rdiv!(A, Transpose(B)) - A_rdiv_Bt!(A::StridedMatrix, B::LowerTriangular) = rdiv!(A, Transpose(B)) - A_rdiv_Bt!(A::StridedMatrix, B::UnitUpperTriangular) = rdiv!(A, Transpose(B)) - A_rdiv_Bt!(A::StridedMatrix, B::UpperTriangular) = rdiv!(A, Transpose(B)) - A_rdiv_Bc!(A::StridedMatrix, B::UnitLowerTriangular) = rdiv!(A, Adjoint(B)) - A_rdiv_Bc!(A::StridedMatrix, B::LowerTriangular) = rdiv!(A, Adjoint(B)) - A_rdiv_Bc!(A::StridedMatrix, B::UnitUpperTriangular) = rdiv!(A, Adjoint(B)) - A_rdiv_Bc!(A::StridedMatrix, B::UpperTriangular) = rdiv!(A, Adjoint(B)) - A_rdiv_B!(A::StridedMatrix, B::UnitLowerTriangular) = rdiv!(A, B) - A_rdiv_B!(A::StridedMatrix, B::LowerTriangular) = rdiv!(A, B) - A_rdiv_B!(A::StridedMatrix, B::UnitUpperTriangular) = rdiv!(A, B) - A_rdiv_B!(A::StridedMatrix, B::UpperTriangular) = rdiv!(A, B) - Ac_ldiv_B!(A::UnitUpperTriangular, b::AbstractVector, x::AbstractVector = b) = ldiv!(Adjoint(A), b, x) - Ac_ldiv_B!(A::UpperTriangular, b::AbstractVector, x::AbstractVector = b) = ldiv!(Adjoint(A), b, x) - Ac_ldiv_B!(A::UnitLowerTriangular, b::AbstractVector, x::AbstractVector = b) = ldiv!(Adjoint(A), b, x) - Ac_ldiv_B!(A::LowerTriangular, b::AbstractVector, x::AbstractVector = b) = ldiv!(Adjoint(A), b, x) - At_ldiv_B!(A::UnitUpperTriangular, b::AbstractVector, x::AbstractVector = b) = ldiv!(Transpose(A), b, x) - At_ldiv_B!(A::UpperTriangular, b::AbstractVector, x::AbstractVector = b) = ldiv!(Transpose(A), b, x) - At_ldiv_B!(A::UnitLowerTriangular, b::AbstractVector, x::AbstractVector = b) = ldiv!(Transpose(A), b, x) - At_ldiv_B!(A::LowerTriangular, b::AbstractVector, x::AbstractVector = b) = ldiv!(Transpose(A), b, x) - A_mul_Bt!(A::StridedMatrix, B::UnitLowerTriangular) = mul!(A, Transpose(B)) - A_mul_Bt!(A::StridedMatrix, B::LowerTriangular) = mul!(A, Transpose(B)) - A_mul_Bt!(A::StridedMatrix, B::UnitUpperTriangular) = mul!(A, Transpose(B)) - A_mul_Bt!(A::StridedMatrix, B::UpperTriangular) = mul!(A, Transpose(B)) - A_mul_Bc!(A::StridedMatrix, B::UnitLowerTriangular) = mul!(A, Adjoint(B)) - A_mul_Bc!(A::StridedMatrix, B::LowerTriangular) = mul!(A, Adjoint(B)) - A_mul_Bc!(A::StridedMatrix, B::UnitUpperTriangular) = mul!(A, Adjoint(B)) - A_mul_Bc!(A::StridedMatrix, B::UpperTriangular) = mul!(A, Adjoint(B)) - A_mul_B!(A::StridedMatrix, B::UnitLowerTriangular) = mul!(A, B) - A_mul_B!(A::StridedMatrix, B::LowerTriangular) = mul!(A, B) - A_mul_B!(A::StridedMatrix, B::UnitUpperTriangular) = mul!(A, B) - A_mul_B!(A::StridedMatrix, B::UpperTriangular) = mul!(A, B) - At_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) = mul!(Transpose(A), B) - At_mul_B!(A::LowerTriangular, B::StridedVecOrMat) = mul!(Transpose(A), B) - At_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) = mul!(Transpose(A), B) - At_mul_B!(A::UpperTriangular, B::StridedVecOrMat) = mul!(Transpose(A), B) - Ac_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) = mul!(Adjoint(A), B) - Ac_mul_B!(A::LowerTriangular, B::StridedVecOrMat) = mul!(Adjoint(A), B) - Ac_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) = mul!(Adjoint(A), B) - Ac_mul_B!(A::UpperTriangular, B::StridedVecOrMat) = mul!(Adjoint(A), B) - A_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) = mul!(A, B) - A_mul_B!(A::LowerTriangular, B::StridedVecOrMat) = mul!(A, B) - A_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) = mul!(A, B) - A_mul_B!(A::UpperTriangular, B::StridedVecOrMat) = mul!(A, B) - A_mul_B!(C::AbstractVector , A::AbstractTriangular, B::AbstractVector) = mul!(C, A, B) - A_mul_B!(C::AbstractMatrix , A::AbstractTriangular, B::AbstractVecOrMat) = mul!(C, A, B) - A_mul_B!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = mul!(C, A, B) - Ac_mul_B!(C::AbstractVector , A::AbstractTriangular, B::AbstractVector) = mul!(C, Adjoint(A), B) - Ac_mul_B!(C::AbstractMatrix , A::AbstractTriangular, B::AbstractVecOrMat) = mul!(C, Adjoint(A), B) - Ac_mul_B!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = mul!(C, Adjoint(A), B) - At_mul_B!(C::AbstractVector , A::AbstractTriangular, B::AbstractVector) = mul!(C, Transpose(A), B) - At_mul_B!(C::AbstractMatrix , A::AbstractTriangular, B::AbstractVecOrMat) = mul!(C, Transpose(A), B) - At_mul_B!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = mul!(C, Transpose(A), B) - A_mul_B!(A::Tridiagonal, B::AbstractTriangular) = mul!(A, B) - A_mul_B!(C::AbstractMatrix, A::AbstractTriangular, B::Tridiagonal) = mul!(C, A, B) - A_mul_B!(C::AbstractMatrix, A::Tridiagonal, B::AbstractTriangular) = mul!(C, A, B) - A_mul_Bt!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = mul!(C, A, Transpose(B)) - A_mul_Bc!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractVecOrMat) = mul!(C, A, Adjoint(B)) - A_mul_Bc!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = mul!(C, A, Adjoint(B)) + @deprecate A_mul_Bc(A::AbstractTriangular, B::AbstractTriangular) (*)(A, Adjoint(B)) + @deprecate A_mul_Bt(A::AbstractTriangular, B::AbstractTriangular) (*)(A, Transpose(B)) + @deprecate Ac_mul_B(A::AbstractTriangular, B::AbstractTriangular) (*)(Adjoint(A), B) + @deprecate At_mul_B(A::AbstractTriangular, B::AbstractTriangular) (*)(Transpose(A), B) + @deprecate Ac_ldiv_B(A::Union{UpperTriangular,LowerTriangular}, B::RowVector) (\)(Adjoint(A), B) + @deprecate Ac_ldiv_B(A::Union{UnitUpperTriangular,UnitLowerTriangular}, B::RowVector) (\)(Adjoint(A), B) + @deprecate At_ldiv_B(A::Union{UpperTriangular,LowerTriangular}, B::RowVector) (\)(Transpose(A), B) + @deprecate At_ldiv_B(A::Union{UnitUpperTriangular,UnitLowerTriangular}, B::RowVector) (\)(Transpose(A), B) + @deprecate A_rdiv_Bc(rowvec::RowVector, A::Union{UpperTriangular,LowerTriangular}) (/)(rowvec, Adjoint(A)) + @deprecate A_rdiv_Bc(rowvec::RowVector, A::Union{UnitUpperTriangular,UnitLowerTriangular}) (/)(rowvec, Adjoint(A)) + @deprecate A_rdiv_Bt(rowvec::RowVector, A::Union{UpperTriangular,LowerTriangular}) (/)(rowvec, Transpose(A)) + @deprecate A_rdiv_Bt(rowvec::RowVector, A::Union{UnitUpperTriangular,UnitLowerTriangular}) (/)(rowvec, Transpose(A)) + @deprecate A_mul_Bt(rowvec::RowVector, A::AbstractTriangular) (*)(rowvec, Transpose(A)) + @deprecate A_mul_Bt(A::AbstractTriangular, rowvec::RowVector) (*)(A, Transpose(rowvec)) + @deprecate At_mul_Bt(A::AbstractTriangular, rowvec::RowVector) (*)(Transpose(A), Transpose(rowvec)) + @deprecate A_mul_Bc(rowvec::RowVector, A::AbstractTriangular) (*)(rowvec, Adjoint(A)) + @deprecate A_mul_Bc(A::AbstractTriangular, rowvec::RowVector) (*)(A, Adjoint(rowvec)) + @deprecate Ac_mul_Bc(A::AbstractTriangular, rowvec::RowVector) (*)(Adjoint(A), Adjoint(rowvec)) + @deprecate Ac_mul_B(A::AbstractMatrix, B::AbstractTriangular) (*)(Adjoint(A), B) + @deprecate At_mul_B(A::AbstractMatrix, B::AbstractTriangular) (*)(Transpose(A), B) + @deprecate A_mul_Bc(A::AbstractTriangular, B::AbstractMatrix) (*)(A, Adjoint(B)) + @deprecate A_mul_Bt(A::AbstractTriangular, B::AbstractMatrix) (*)(A, Transpose(B)) + @deprecate Ac_mul_Bc(A::AbstractTriangular, B::AbstractTriangular) (*)(Adjoint(A), Adjoint(B)) + @deprecate Ac_mul_Bc(A::AbstractTriangular, B::AbstractMatrix) (*)(Adjoint(A), Adjoint(B)) + @deprecate Ac_mul_Bc(A::AbstractMatrix, B::AbstractTriangular) (*)(Adjoint(A), Adjoint(B)) + @deprecate At_mul_Bt(A::AbstractTriangular, B::AbstractTriangular) (*)(Transpose(A), Transpose(B)) + @deprecate At_mul_Bt(A::AbstractTriangular, B::AbstractMatrix) (*)(Transpose(A), Transpose(B)) + @deprecate At_mul_Bt(A::AbstractMatrix, B::AbstractTriangular) (*)(Transpose(A), Transpose(B)) + @deprecate A_mul_Bc!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) mul!(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) mul!(A, Adjoint(B)) + @deprecate A_mul_Bt!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) mul!(A, Transpose(B)) + @deprecate A_mul_Bt!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) mul!(A, Transpose(B)) + @deprecate A_rdiv_Bc!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) rdiv!(A, Adjoint(B)) + @deprecate A_rdiv_Bc!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) rdiv!(A, Adjoint(B)) + @deprecate A_rdiv_Bt!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) rdiv!(A, Transpose(B)) + @deprecate A_rdiv_Bt!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) rdiv!(A, Transpose(B)) + @deprecate A_rdiv_B!(A::UpperTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) rdiv!(A, B) + @deprecate A_rdiv_B!(A::LowerTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) rdiv!(A, B) + @deprecate Ac_mul_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) mul!(Adjoint(A), B) + @deprecate Ac_mul_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) mul!(Adjoint(A), B) + @deprecate At_mul_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) mul!(Transpose(A), B) + @deprecate At_mul_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) mul!(Transpose(A), B) + @deprecate Ac_ldiv_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) ldiv!(Adjoint(A), B) + @deprecate Ac_ldiv_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) ldiv!(Adjoint(A), B) + @deprecate At_ldiv_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) ldiv!(Transpose(A), B) + @deprecate At_ldiv_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) ldiv!(Transpose(A), B) + @deprecate A_rdiv_Bt!(A::StridedMatrix, B::UnitLowerTriangular) rdiv!(A, Transpose(B)) + @deprecate A_rdiv_Bt!(A::StridedMatrix, B::LowerTriangular) rdiv!(A, Transpose(B)) + @deprecate A_rdiv_Bt!(A::StridedMatrix, B::UnitUpperTriangular) rdiv!(A, Transpose(B)) + @deprecate A_rdiv_Bt!(A::StridedMatrix, B::UpperTriangular) rdiv!(A, Transpose(B)) + @deprecate A_rdiv_Bc!(A::StridedMatrix, B::UnitLowerTriangular) rdiv!(A, Adjoint(B)) + @deprecate A_rdiv_Bc!(A::StridedMatrix, B::LowerTriangular) rdiv!(A, Adjoint(B)) + @deprecate A_rdiv_Bc!(A::StridedMatrix, B::UnitUpperTriangular) rdiv!(A, Adjoint(B)) + @deprecate A_rdiv_Bc!(A::StridedMatrix, B::UpperTriangular) rdiv!(A, Adjoint(B)) + @deprecate A_rdiv_B!(A::StridedMatrix, B::UnitLowerTriangular) rdiv!(A, B) + @deprecate A_rdiv_B!(A::StridedMatrix, B::LowerTriangular) rdiv!(A, B) + @deprecate A_rdiv_B!(A::StridedMatrix, B::UnitUpperTriangular) rdiv!(A, B) + @deprecate A_rdiv_B!(A::StridedMatrix, B::UpperTriangular) rdiv!(A, B) + @deprecate Ac_ldiv_B!(A::UnitUpperTriangular, b::AbstractVector, x::AbstractVector = b) ldiv!(Adjoint(A), b, x) + @deprecate Ac_ldiv_B!(A::UpperTriangular, b::AbstractVector, x::AbstractVector = b) ldiv!(Adjoint(A), b, x) + @deprecate Ac_ldiv_B!(A::UnitLowerTriangular, b::AbstractVector, x::AbstractVector = b) ldiv!(Adjoint(A), b, x) + @deprecate Ac_ldiv_B!(A::LowerTriangular, b::AbstractVector, x::AbstractVector = b) ldiv!(Adjoint(A), b, x) + @deprecate At_ldiv_B!(A::UnitUpperTriangular, b::AbstractVector, x::AbstractVector = b) ldiv!(Transpose(A), b, x) + @deprecate At_ldiv_B!(A::UpperTriangular, b::AbstractVector, x::AbstractVector = b) ldiv!(Transpose(A), b, x) + @deprecate At_ldiv_B!(A::UnitLowerTriangular, b::AbstractVector, x::AbstractVector = b) ldiv!(Transpose(A), b, x) + @deprecate At_ldiv_B!(A::LowerTriangular, b::AbstractVector, x::AbstractVector = b) ldiv!(Transpose(A), b, x) + @deprecate A_mul_Bt!(A::StridedMatrix, B::UnitLowerTriangular) mul!(A, Transpose(B)) + @deprecate A_mul_Bt!(A::StridedMatrix, B::LowerTriangular) mul!(A, Transpose(B)) + @deprecate A_mul_Bt!(A::StridedMatrix, B::UnitUpperTriangular) mul!(A, Transpose(B)) + @deprecate A_mul_Bt!(A::StridedMatrix, B::UpperTriangular) mul!(A, Transpose(B)) + @deprecate A_mul_Bc!(A::StridedMatrix, B::UnitLowerTriangular) mul!(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::StridedMatrix, B::LowerTriangular) mul!(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::StridedMatrix, B::UnitUpperTriangular) mul!(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::StridedMatrix, B::UpperTriangular) mul!(A, Adjoint(B)) + @deprecate A_mul_B!(A::StridedMatrix, B::UnitLowerTriangular) mul!(A, B) + @deprecate A_mul_B!(A::StridedMatrix, B::LowerTriangular) mul!(A, B) + @deprecate A_mul_B!(A::StridedMatrix, B::UnitUpperTriangular) mul!(A, B) + @deprecate A_mul_B!(A::StridedMatrix, B::UpperTriangular) mul!(A, B) + @deprecate At_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) mul!(Transpose(A), B) + @deprecate At_mul_B!(A::LowerTriangular, B::StridedVecOrMat) mul!(Transpose(A), B) + @deprecate At_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) mul!(Transpose(A), B) + @deprecate At_mul_B!(A::UpperTriangular, B::StridedVecOrMat) mul!(Transpose(A), B) + @deprecate Ac_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) mul!(Adjoint(A), B) + @deprecate Ac_mul_B!(A::LowerTriangular, B::StridedVecOrMat) mul!(Adjoint(A), B) + @deprecate Ac_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) mul!(Adjoint(A), B) + @deprecate Ac_mul_B!(A::UpperTriangular, B::StridedVecOrMat) mul!(Adjoint(A), B) + @deprecate A_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) mul!(A, B) + @deprecate A_mul_B!(A::LowerTriangular, B::StridedVecOrMat) mul!(A, B) + @deprecate A_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) mul!(A, B) + @deprecate A_mul_B!(A::UpperTriangular, B::StridedVecOrMat) mul!(A, B) + @deprecate A_mul_B!(C::AbstractVector , A::AbstractTriangular, B::AbstractVector) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractMatrix , A::AbstractTriangular, B::AbstractVecOrMat) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) mul!(C, A, B) + @deprecate Ac_mul_B!(C::AbstractVector , A::AbstractTriangular, B::AbstractVector) mul!(C, Adjoint(A), B) + @deprecate Ac_mul_B!(C::AbstractMatrix , A::AbstractTriangular, B::AbstractVecOrMat) mul!(C, Adjoint(A), B) + @deprecate Ac_mul_B!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) mul!(C, Adjoint(A), B) + @deprecate At_mul_B!(C::AbstractVector , A::AbstractTriangular, B::AbstractVector) mul!(C, Transpose(A), B) + @deprecate At_mul_B!(C::AbstractMatrix , A::AbstractTriangular, B::AbstractVecOrMat) mul!(C, Transpose(A), B) + @deprecate At_mul_B!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) mul!(C, Transpose(A), B) + @deprecate A_mul_B!(A::Tridiagonal, B::AbstractTriangular) mul!(A, B) + @deprecate A_mul_B!(C::AbstractMatrix, A::AbstractTriangular, B::Tridiagonal) mul!(C, A, B) + @deprecate A_mul_B!(C::AbstractMatrix, A::Tridiagonal, B::AbstractTriangular) mul!(C, A, B) + @deprecate A_mul_Bt!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) mul!(C, A, Transpose(B)) + @deprecate A_mul_Bc!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractVecOrMat) mul!(C, A, Adjoint(B)) + @deprecate A_mul_Bc!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) mul!(C, A, Adjoint(B)) end for mat in (:AbstractVector, :AbstractMatrix) @eval Base.LinAlg begin - Ac_mul_B(A::AbstractTriangular, B::$mat) = *(Adjoint(A), B) - At_mul_B(A::AbstractTriangular, B::$mat) = *(Transpose(A), B) - Ac_ldiv_B(A::Union{UnitUpperTriangular,UnitLowerTriangular}, B::$mat) = \(Adjoint(A), B) - At_ldiv_B(A::Union{UnitUpperTriangular,UnitLowerTriangular}, B::$mat) = \(Transpose(A), B) - Ac_ldiv_B(A::Union{UpperTriangular,LowerTriangular}, B::$mat) = \(Adjoint(A), B) - At_ldiv_B(A::Union{UpperTriangular,LowerTriangular}, B::$mat) = \(Transpose(A), B) - A_rdiv_Bc(A::$mat, B::Union{UnitUpperTriangular, UnitLowerTriangular}) = /(A, Adjoint(B)) - A_rdiv_Bt(A::$mat, B::Union{UnitUpperTriangular, UnitLowerTriangular}) = /(A, Transpose(B)) - A_rdiv_Bc(A::$mat, B::Union{UpperTriangular,LowerTriangular}) = /(A, Adjoint(B)) - A_rdiv_Bt(A::$mat, B::Union{UpperTriangular,LowerTriangular}) = /(A, Transpose(B)) + @deprecate Ac_mul_B(A::AbstractTriangular, B::$mat) (*)(Adjoint(A), B) + @deprecate At_mul_B(A::AbstractTriangular, B::$mat) (*)(Transpose(A), B) + @deprecate Ac_ldiv_B(A::Union{UnitUpperTriangular,UnitLowerTriangular}, B::$mat) (\)(Adjoint(A), B) + @deprecate At_ldiv_B(A::Union{UnitUpperTriangular,UnitLowerTriangular}, B::$mat) (\)(Transpose(A), B) + @deprecate Ac_ldiv_B(A::Union{UpperTriangular,LowerTriangular}, B::$mat) (\)(Adjoint(A), B) + @deprecate At_ldiv_B(A::Union{UpperTriangular,LowerTriangular}, B::$mat) (\)(Transpose(A), B) + @deprecate A_rdiv_Bc(A::$mat, B::Union{UnitUpperTriangular, UnitLowerTriangular}) (/)(A, Adjoint(B)) + @deprecate A_rdiv_Bt(A::$mat, B::Union{UnitUpperTriangular, UnitLowerTriangular}) (/)(A, Transpose(B)) + @deprecate A_rdiv_Bc(A::$mat, B::Union{UpperTriangular,LowerTriangular}) (/)(A, Adjoint(B)) + @deprecate A_rdiv_Bt(A::$mat, B::Union{UpperTriangular,LowerTriangular}) (/)(A, Transpose(B)) end end @eval Base.LinAlg begin - A_mul_Bc(A::AbstractMatrix, B::AbstractTriangular) = *(A, Adjoint(B)) - A_mul_Bt(A::AbstractMatrix, B::AbstractTriangular) = *(A, Transpose(B)) + @deprecate A_mul_Bc(A::AbstractMatrix, B::AbstractTriangular) (*)(A, Adjoint(B)) + @deprecate A_mul_Bt(A::AbstractMatrix, B::AbstractTriangular) (*)(A, Transpose(B)) end for (f, op, transform) in ( (:A_mul_Bc, :*, :Adjoint), @@ -2697,10 +2735,10 @@ for (f, op, transform) in ( (:A_rdiv_Bc, :/, :Adjoint), (:A_rdiv_Bt, :/, :Transpose)) @eval Base.LinAlg begin - $f(A::LowerTriangular, B::UpperTriangular) = ($op)(A, ($transform)(B)) - $f(A::LowerTriangular, B::UnitUpperTriangular) = ($op)(A, ($transform)(B)) - $f(A::UpperTriangular, B::LowerTriangular) = ($op)(A, ($transform)(B)) - $f(A::UpperTriangular, B::UnitLowerTriangular) = ($op)(A, ($transform)(B)) + @deprecate $f(A::LowerTriangular, B::UpperTriangular) ($op)(A, ($transform)(B)) + @deprecate $f(A::LowerTriangular, B::UnitUpperTriangular) ($op)(A, ($transform)(B)) + @deprecate $f(A::UpperTriangular, B::LowerTriangular) ($op)(A, ($transform)(B)) + @deprecate $f(A::UpperTriangular, B::UnitLowerTriangular) ($op)(A, ($transform)(B)) end end for (f, op, transform) in ( @@ -2709,10 +2747,10 @@ for (f, op, transform) in ( (:Ac_ldiv_B, :\, :Adjoint), (:At_ldiv_B, :\, :Transpose)) @eval Base.LinAlg begin - ($f)(A::UpperTriangular, B::LowerTriangular) = ($op)(($transform)(A), B) - ($f)(A::UnitUpperTriangular, B::LowerTriangular) = ($op)(($transform)(A), B) - ($f)(A::LowerTriangular, B::UpperTriangular) = ($op)(($transform)(A), B) - ($f)(A::UnitLowerTriangular, B::UpperTriangular) = ($op)(($transform)(A), B) + @deprecate ($f)(A::UpperTriangular, B::LowerTriangular) ($op)(($transform)(A), B) + @deprecate ($f)(A::UnitUpperTriangular, B::LowerTriangular) ($op)(($transform)(A), B) + @deprecate ($f)(A::LowerTriangular, B::UpperTriangular) ($op)(($transform)(A), B) + @deprecate ($f)(A::UnitLowerTriangular, B::UpperTriangular) ($op)(($transform)(A), B) end end for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'), @@ -2721,106 +2759,135 @@ for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'), (:UnitUpperTriangular, 'U', 'U')) @eval Base.LinAlg begin # Vector multiplication - A_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} = mul!(A, b) - At_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} = mul!(Transpose(A), b) - Ac_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasReal} = mul!(Adjoint(A), b) - Ac_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasComplex} = mul!(Adjoint(A), b) + @deprecate A_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} mul!(A, b) + @deprecate At_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} mul!(Transpose(A), b) + @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasReal} mul!(Adjoint(A), b) + @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasComplex} mul!(Adjoint(A), b) # Matrix multiplication - A_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} = mul!(A, B) - A_mul_B!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} = mul!(A, B) + @deprecate A_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} mul!(A, B) + @deprecate A_mul_B!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} mul!(A, B) - At_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} = mul!(Transpose(A), B) - Ac_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasComplex} = mul!(Adjoint(A), B) - Ac_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasReal} = mul!(Adjoint(A), B) + @deprecate At_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} mul!(Transpose(A), B) + @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasComplex} mul!(Adjoint(A), B) + @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasReal} mul!(Adjoint(A), B) - A_mul_Bt!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} = mul!(A, Transpose(B)) - A_mul_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasComplex} = mul!(A, Adjoint(B)) - A_mul_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasReal} = mul!(A, Adjoint(B)) + @deprecate A_mul_Bt!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} mul!(A, Transpose(B)) + @deprecate A_mul_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasComplex} mul!(A, Adjoint(B)) + @deprecate A_mul_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasReal} mul!(A, Adjoint(B)) # Left division - A_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = ldiv!(A, B) - At_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = ldiv!(Transpose(A), B) - Ac_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasReal} = ldiv!(Adjoint(A), B) - Ac_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = ldiv!(Adjoint(A), B) + @deprecate A_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} ldiv!(A, B) + @deprecate At_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} ldiv!(Transpose(A), B) + @deprecate Ac_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasReal} ldiv!(Adjoint(A), B) + @deprecate Ac_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasComplex} ldiv!(Adjoint(A), B) # Right division - A_rdiv_B!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} = rdiv!(A, B) - A_rdiv_Bt!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} = rdiv!(A, Transpose(B)) - A_rdiv_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasReal} = rdiv!(A, Adjoint(B)) - A_rdiv_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasComplex} = rdiv!(A, Adjoint(B)) + @deprecate A_rdiv_B!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} rdiv!(A, B) + @deprecate A_rdiv_Bt!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} rdiv!(A, Transpose(B)) + @deprecate A_rdiv_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasReal} rdiv!(A, Adjoint(B)) + @deprecate A_rdiv_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasComplex} rdiv!(A, Adjoint(B)) end end -@eval Base.LinAlg begin - """ - A_ldiv_B!([Y,] A, B) -> Y - - Compute `A \\ B` in-place and store the result in `Y`, returning the result. - If only two arguments are passed, then `A_ldiv_B!(A, B)` overwrites `B` with - the result. - - The argument `A` should *not* be a matrix. Rather, instead of matrices it should be a - factorization object (e.g. produced by [`factorize`](@ref) or [`cholfact`](@ref)). - The reason for this is that factorization itself is both expensive and typically allocates memory - (although it can also be done in-place via, e.g., [`lufact!`](@ref)), - and performance-critical situations requiring `A_ldiv_B!` usually also require fine-grained - control over the factorization of `A`. - """ - A_ldiv_B! - - """ - Ac_ldiv_B!([Y,] A, B) -> Y - Similar to [`A_ldiv_B!`](@ref), but return ``Aᴴ`` \\ ``B``, - computing the result in-place in `Y` (or overwriting `B` if `Y` is not supplied). - """ - Ac_ldiv_B! +# A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/rowvector.jl, to deprecate +@eval Base.LinAlg begin + @deprecate A_rdiv_Bt(rowvec::RowVector, mat::AbstractMatrix) (/)(rowvec, Transpose(mat)) + @deprecate A_rdiv_Bc(rowvec::RowVector, mat::AbstractMatrix) (/)(rowvec, Adjoint(mat)) + @deprecate At_ldiv_B(mat::AbstractMatrix, rowvec::RowVector) (\)(Transpose(mat), rowvec) + @deprecate Ac_ldiv_B(mat::AbstractMatrix, rowvec::RowVector) (\)(Adjoint(mat), rowvec) + @deprecate Ac_mul_B(u::RowVector, v::AbstractVector) (*)(Adjoint(u), v) + @deprecate Ac_mul_B(vec::AbstractVector, mat::AbstractMatrix) (*)(Adjoint(vec), mat) + @deprecate Ac_mul_B(rowvec1::RowVector, rowvec2::RowVector) (*)(Adjoint(rowvec1), rowvec2) + @deprecate Ac_mul_B(vec::AbstractVector, rowvec::RowVector) (*)(Adjoint(vec), rowvec) + @deprecate Ac_mul_B(vec1::AbstractVector, vec2::AbstractVector) (*)(Adjoint(vec1), vec2) + @deprecate Ac_mul_Bc(rowvec::RowVector, vec::AbstractVector) (*)(Adjoint(rowvec), Adjoint(vec)) + @deprecate Ac_mul_Bc(vec::AbstractVector, mat::AbstractMatrix) (*)(Adjoint(vec), Adjoint(mat)) + @deprecate Ac_mul_Bc(rowvec1::RowVector, rowvec2::RowVector) (*)(Adjoint(rowvec1), Adjoint(rowvec2)) + @deprecate Ac_mul_Bc(vec::AbstractVector, rowvec::RowVector) (*)(Adjoint(vec), Adjoint(rowvec)) + @deprecate Ac_mul_Bc(vec::AbstractVector, rowvec::AbstractVector) (*)(Adjoint(vec), Adjoint(rowvec)) + @deprecate Ac_mul_Bc(mat::AbstractMatrix, rowvec::RowVector) (*)(Adjoint(mat), Adjoint(rowvec)) + @deprecate A_mul_Bc(u::RowVector, v::AbstractVector) (*)(u, Adjoint(v)) + @deprecate A_mul_Bc(rowvec::RowVector, mat::AbstractMatrix) (*)(rowvec, Adjoint(mat)) + @deprecate A_mul_Bc(rowvec1::RowVector, rowvec2::RowVector) (*)(rowvec1, Adjoint(rowvec2)) + @deprecate A_mul_Bc(vec::AbstractVector, rowvec::RowVector) (*)(vec, Adjoint(rowvec)) + @deprecate A_mul_Bc(vec1::AbstractVector, vec2::AbstractVector) (*)(vec1, Adjoint(vec2)) + @deprecate A_mul_Bc(mat::AbstractMatrix, rowvec::RowVector) (*)(mat, Adjoint(rowvec)) + @deprecate At_mul_B(v::RowVector, u::AbstractVector) (*)(Transpose(v), u) + @deprecate At_mul_B(vec::AbstractVector, mat::AbstractMatrix) (*)(Transpose(vec), mat) + @deprecate At_mul_B(rowvec1::RowVector, rowvec2::RowVector) (*)(Transpose(rowvec1), rowvec2) + @deprecate At_mul_B(vec::AbstractVector, rowvec::RowVector) (*)(Transpose(vec), rowvec) + @deprecate At_mul_B(vec1::AbstractVector{T}, vec2::AbstractVector{T}) where {T<:Real} (*)(Transpose(vec1), vec2) + @deprecate At_mul_B(vec1::AbstractVector, vec2::AbstractVector) (*)(Transpose(vec1), vec2) + @deprecate At_mul_Bt(rowvec::RowVector, vec::AbstractVector) (*)(Transpose(rowvec), Transpose(vec)) + @deprecate At_mul_Bt(vec::AbstractVector, mat::AbstractMatrix) (*)(Transpose(vec), Transpose(mat)) + @deprecate At_mul_Bt(rowvec1::RowVector, rowvec2::RowVector) (*)(Transpose(rowvec1), Transpose(rowvec2)) + @deprecate At_mul_Bt(vec::AbstractVector, rowvec::RowVector) (*)(Transpose(vec), Transpose(rowvec)) + @deprecate At_mul_Bt(vec::AbstractVector, rowvec::AbstractVector) (*)(Transpose(vec), Transpose(rowvec)) + @deprecate At_mul_Bt(mat::AbstractMatrix, rowvec::RowVector) (*)(Transpose(mat), Transpose(rowvec)) + @deprecate A_mul_Bt(v::RowVector, A::AbstractVector) (*)(v, Transpose(A)) + @deprecate A_mul_Bt(rowvec::RowVector, mat::AbstractMatrix) (*)(rowvec, Transpose(mat)) + @deprecate A_mul_Bt(rowvec1::RowVector, rowvec2::RowVector) (*)(rowvec1, Transpose(rowvec2)) + @deprecate A_mul_Bt(vec::AbstractVector, rowvec::RowVector) (*)(vec, Transpose(rowvec)) + @deprecate A_mul_Bt(vec1::AbstractVector, vec2::AbstractVector) (*)(vec1, Transpose(vec2)) + @deprecate A_mul_Bt(mat::AbstractMatrix, rowvec::RowVector) (*)(mat, Transpose(rowvec)) +end - """ - At_ldiv_B!([Y,] A, B) -> Y +# A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/givens.jl, to deprecate +@eval Base.LinAlg begin + @deprecate A_mul_Bc!(A::AbstractMatrix, R::Rotation) mul!(A, Adjoint(R)) + @deprecate A_mul_B!(R::Rotation, A::AbstractMatrix) mul!(R, A) + @deprecate A_mul_B!(G::Givens, R::Rotation) mul!(G, R) + @deprecate A_mul_Bc!(A::AbstractMatrix, G::Givens) mul!(A, Adjoint(G)) + @deprecate A_mul_B!(G::Givens, A::AbstractVecOrMat) mul!(G, A) + @deprecate A_mul_B!(G1::Givens, G2::Givens) mul!(G1, G2) + @deprecate A_mul_Bc(A::AbstractVecOrMat{T}, R::AbstractRotation{S}) where {T,S} (*)(A, Adjoint(R)) +end - Similar to [`A_ldiv_B!`](@ref), but return ``Aᵀ`` \\ ``B``, - computing the result in-place in `Y` (or overwriting `B` if `Y` is not supplied). - """ - At_ldiv_B! +# former imports into SparseArrays +@eval Base.SparseArrays begin + import Base: A_mul_B!, Ac_mul_B, Ac_mul_B!, At_mul_B, At_mul_B! + import Base: A_mul_Bc, A_mul_Bt, Ac_mul_Bc, At_mul_Bt + import Base: At_ldiv_B, Ac_ldiv_B, A_ldiv_B! + import Base.LinAlg: At_ldiv_B!, Ac_ldiv_B!, A_rdiv_B!, A_rdiv_Bc!, mul!, ldiv!, rdiv! end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/sparse/linalg.jl, to deprecate @eval Base.SparseArrays begin using Base.LinAlg: Adjoint, Transpose - Ac_ldiv_B(A::SparseMatrixCSC, B::RowVector) = \(Adjoint(A), B) - At_ldiv_B(A::SparseMatrixCSC, B::RowVector) = \(Transpose(A), B) - Ac_ldiv_B(A::SparseMatrixCSC, B::AbstractVecOrMat) = \(Adjoint(A), B) - At_ldiv_B(A::SparseMatrixCSC, B::AbstractVecOrMat) = \(Transpose(A), B) - A_rdiv_Bc!(A::SparseMatrixCSC{T}, D::Diagonal{T}) where {T} = rdiv!(A, Adjoint(D)) - A_rdiv_Bt!(A::SparseMatrixCSC{T}, D::Diagonal{T}) where {T} = rdiv!(A, Transpose(D)) - A_rdiv_B!(A::SparseMatrixCSC{T}, D::Diagonal{T}) where {T} = rdiv!(A, D) - A_ldiv_B!(L::LowerTriangular{T,<:SparseMatrixCSCUnion{T}}, B::StridedVecOrMat) where {T} = ldiv!(L, B) - A_ldiv_B!(U::UpperTriangular{T,<:SparseMatrixCSCUnion{T}}, B::StridedVecOrMat) where {T} = ldiv!(U, B) - A_mul_Bt(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} = *(A, Transpose(B)) - A_mul_Bc(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} = *(A, Adjoint(B)) - At_mul_B(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} = *(Transpose(A), B) - Ac_mul_B(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} = *(Adjoint(A), B) - At_mul_Bt(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} = *(Transpose(A), Transpose(B)) - Ac_mul_Bc(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} = *(Adjoint(A), Adjoint(B)) - A_mul_B!(C::StridedVecOrMat, A::SparseMatrixCSC, B::StridedVecOrMat) = mul!(C, A, B) - Ac_mul_B!(C::StridedVecOrMat, A::SparseMatrixCSC, B::StridedVecOrMat) = mul!(C, Adjoint(A), B) - At_mul_B!(C::StridedVecOrMat, A::SparseMatrixCSC, B::StridedVecOrMat) = mul!(C, Transpose(A), B) - A_mul_B!(α::Number, A::SparseMatrixCSC, B::StridedVecOrMat, β::Number, C::StridedVecOrMat) = mul!(α, A, B, β, C) - A_mul_B(A::SparseMatrixCSC{TA,S}, x::StridedVector{Tx}) where {TA,S,Tx} = *(A, x) - A_mul_B(A::SparseMatrixCSC{TA,S}, B::StridedMatrix{Tx}) where {TA,S,Tx} = *(A, B) - Ac_mul_B!(α::Number, A::SparseMatrixCSC, B::StridedVecOrMat, β::Number, C::StridedVecOrMat) = mul!(α, Adjoint(A), B, β, C) - Ac_mul_B(A::SparseMatrixCSC{TA,S}, x::StridedVector{Tx}) where {TA,S,Tx} = *(Adjoint(A), x) - Ac_mul_B(A::SparseMatrixCSC{TA,S}, B::StridedMatrix{Tx}) where {TA,S,Tx} = *(Adjoint(A), B) - At_mul_B!(α::Number, A::SparseMatrixCSC, B::StridedVecOrMat, β::Number, C::StridedVecOrMat) = mul!(α, Transpose(A), B, β, C) - At_mul_B(A::SparseMatrixCSC{TA,S}, x::StridedVector{Tx}) where {TA,S,Tx} = *(Transpose(A), x) - At_mul_B(A::SparseMatrixCSC{TA,S}, B::StridedMatrix{Tx}) where {TA,S,Tx} = *(Transpose(A), B) - A_mul_Bt(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} = *(A, Transpose(B)) - A_mul_Bc(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} = *(A, Adjoint(B)) - At_mul_B(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} = *(Transpose(A), B) - Ac_mul_B(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} = *(Adjoint(A),B) - At_mul_Bt(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} = *(Transpose(A), Transpose(B)) - Ac_mul_Bc(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} = *(Adjoint(A), Adjoint(B)) + @deprecate Ac_ldiv_B(A::SparseMatrixCSC, B::RowVector) (\)(Adjoint(A), B) + @deprecate At_ldiv_B(A::SparseMatrixCSC, B::RowVector) (\)(Transpose(A), B) + @deprecate Ac_ldiv_B(A::SparseMatrixCSC, B::AbstractVecOrMat) (\)(Adjoint(A), B) + @deprecate At_ldiv_B(A::SparseMatrixCSC, B::AbstractVecOrMat) (\)(Transpose(A), B) + @deprecate A_rdiv_Bc!(A::SparseMatrixCSC{T}, D::Diagonal{T}) where {T} rdiv!(A, Adjoint(D)) + @deprecate A_rdiv_Bt!(A::SparseMatrixCSC{T}, D::Diagonal{T}) where {T} rdiv!(A, Transpose(D)) + @deprecate A_rdiv_B!(A::SparseMatrixCSC{T}, D::Diagonal{T}) where {T} rdiv!(A, D) + @deprecate A_ldiv_B!(L::LowerTriangular{T,<:SparseMatrixCSCUnion{T}}, B::StridedVecOrMat) where {T} ldiv!(L, B) + @deprecate A_ldiv_B!(U::UpperTriangular{T,<:SparseMatrixCSCUnion{T}}, B::StridedVecOrMat) where {T} ldiv!(U, B) + @deprecate A_mul_Bt(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} (*)(A, Transpose(B)) + @deprecate A_mul_Bc(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} (*)(A, Adjoint(B)) + @deprecate At_mul_B(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} (*)(Transpose(A), B) + @deprecate Ac_mul_B(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} (*)(Adjoint(A), B) + @deprecate At_mul_Bt(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} (*)(Transpose(A), Transpose(B)) + @deprecate Ac_mul_Bc(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} (*)(Adjoint(A), Adjoint(B)) + @deprecate A_mul_B!(C::StridedVecOrMat, A::SparseMatrixCSC, B::StridedVecOrMat) mul!(C, A, B) + @deprecate Ac_mul_B!(C::StridedVecOrMat, A::SparseMatrixCSC, B::StridedVecOrMat) mul!(C, Adjoint(A), B) + @deprecate At_mul_B!(C::StridedVecOrMat, A::SparseMatrixCSC, B::StridedVecOrMat) mul!(C, Transpose(A), B) + @deprecate A_mul_B!(α::Number, A::SparseMatrixCSC, B::StridedVecOrMat, β::Number, C::StridedVecOrMat) mul!(α, A, B, β, C) + @deprecate A_mul_B(A::SparseMatrixCSC{TA,S}, x::StridedVector{Tx}) where {TA,S,Tx} (*)(A, x) + @deprecate A_mul_B(A::SparseMatrixCSC{TA,S}, B::StridedMatrix{Tx}) where {TA,S,Tx} (*)(A, B) + @deprecate Ac_mul_B!(α::Number, A::SparseMatrixCSC, B::StridedVecOrMat, β::Number, C::StridedVecOrMat) mul!(α, Adjoint(A), B, β, C) + @deprecate Ac_mul_B(A::SparseMatrixCSC{TA,S}, x::StridedVector{Tx}) where {TA,S,Tx} (*)(Adjoint(A), x) + @deprecate Ac_mul_B(A::SparseMatrixCSC{TA,S}, B::StridedMatrix{Tx}) where {TA,S,Tx} (*)(Adjoint(A), B) + @deprecate At_mul_B!(α::Number, A::SparseMatrixCSC, B::StridedVecOrMat, β::Number, C::StridedVecOrMat) mul!(α, Transpose(A), B, β, C) + @deprecate At_mul_B(A::SparseMatrixCSC{TA,S}, x::StridedVector{Tx}) where {TA,S,Tx} (*)(Transpose(A), x) + @deprecate At_mul_B(A::SparseMatrixCSC{TA,S}, B::StridedMatrix{Tx}) where {TA,S,Tx} (*)(Transpose(A), B) + @deprecate A_mul_Bt(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} (*)(A, Transpose(B)) + @deprecate A_mul_Bc(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} (*)(A, Adjoint(B)) + @deprecate At_mul_B(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} (*)(Transpose(A), B) + @deprecate Ac_mul_B(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} (*)(Adjoint(A),B) + @deprecate At_mul_Bt(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} (*)(Transpose(A), Transpose(B)) + @deprecate Ac_mul_Bc(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB} (*)(Adjoint(A), Adjoint(B)) end # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/sparse/sparsevector.jl, to deprecate @@ -2830,209 +2897,34 @@ for isunittri in (true, false), islowertri in (true, false) tritype = :(Base.LinAlg.$(Symbol(unitstr, halfstr, "Triangular"))) @eval Base.SparseArrays begin using Base.LinAlg: Adjoint, Transpose - At_ldiv_B(A::$tritype{TA,<:AbstractMatrix}, b::SparseVector{Tb}) where {TA<:Number,Tb<:Number} = \(Transpose(A), b) - At_ldiv_B(A::$tritype{TA,<:StridedMatrix}, b::SparseVector{Tb}) where {TA<:Number,Tb<:Number} = \(Transpose(A), b) - At_ldiv_B(A::$tritype, b::SparseVector) = \(Transpose(A), b) - Ac_ldiv_B(A::$tritype{TA,<:AbstractMatrix}, b::SparseVector{Tb}) where {TA<:Number,Tb<:Number} = \(Adjoint(A), b) - Ac_ldiv_B(A::$tritype{TA,<:StridedMatrix}, b::SparseVector{Tb}) where {TA<:Number,Tb<:Number} = \(Adjoint(A), b) - Ac_ldiv_B(A::$tritype, b::SparseVector) = \(Adjoint(A), b) - A_ldiv_B!(A::$tritype{<:Any,<:StridedMatrix}, b::SparseVector) = ldiv!(A, b) - At_ldiv_B!(A::$tritype{<:Any,<:StridedMatrix}, b::SparseVector) = ldiv!(Transpose(A), b) - Ac_ldiv_B!(A::$tritype{<:Any,<:StridedMatrix}, b::SparseVector) = ldiv!(Adjoint(A), b) + @deprecate At_ldiv_B(A::$tritype{TA,<:AbstractMatrix}, b::SparseVector{Tb}) where {TA<:Number,Tb<:Number} (\)(Transpose(A), b) + @deprecate At_ldiv_B(A::$tritype{TA,<:StridedMatrix}, b::SparseVector{Tb}) where {TA<:Number,Tb<:Number} (\)(Transpose(A), b) + @deprecate At_ldiv_B(A::$tritype, b::SparseVector) (\)(Transpose(A), b) + @deprecate Ac_ldiv_B(A::$tritype{TA,<:AbstractMatrix}, b::SparseVector{Tb}) where {TA<:Number,Tb<:Number} (\)(Adjoint(A), b) + @deprecate Ac_ldiv_B(A::$tritype{TA,<:StridedMatrix}, b::SparseVector{Tb}) where {TA<:Number,Tb<:Number} (\)(Adjoint(A), b) + @deprecate Ac_ldiv_B(A::$tritype, b::SparseVector) (\)(Adjoint(A), b) + @deprecate A_ldiv_B!(A::$tritype{<:Any,<:StridedMatrix}, b::SparseVector) ldiv!(A, b) + @deprecate At_ldiv_B!(A::$tritype{<:Any,<:StridedMatrix}, b::SparseVector) ldiv!(Transpose(A), b) + @deprecate Ac_ldiv_B!(A::$tritype{<:Any,<:StridedMatrix}, b::SparseVector) ldiv!(Adjoint(A), b) end end @eval Base.SparseArrays begin using Base.LinAlg: Adjoint, Transpose - Ac_mul_B(A::SparseMatrixCSC, x::AbstractSparseVector) = *(Adjoint(A), x) - At_mul_B(A::SparseMatrixCSC, x::AbstractSparseVector) = *(Transpose(A), x) - Ac_mul_B!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Number, y::StridedVector) = mul!(α, Adjoint(A), x, β, y) - Ac_mul_B!(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) where {Tx,Ty} = mul!(y, Adjoint(A), x) - At_mul_B!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Number, y::StridedVector) = mul!(α, Transpose(A), x, β, y) - At_mul_B!(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) where {Tx,Ty} = mul!(y, Transpose(A), x) - A_mul_B!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Number, y::StridedVector) = mul!(α, A, x, β, y) - A_mul_B!(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) where {Tx,Ty} = mul!(y, A, x) - At_mul_B!(α::Number, A::StridedMatrix, x::AbstractSparseVector, β::Number, y::StridedVector) = mul!(α, Transpose(A), x, β, y) - At_mul_B!(y::StridedVector{Ty}, A::StridedMatrix, x::AbstractSparseVector{Tx}) where {Tx,Ty} = mul!(y, Transpose(A), x) - At_mul_B(A::StridedMatrix{Ta}, x::AbstractSparseVector{Tx}) where {Ta,Tx} = *(Transpose(A), x) - A_mul_B!(α::Number, A::StridedMatrix, x::AbstractSparseVector, β::Number, y::StridedVector) = mul!(α, A, x, β, y) - A_mul_B!(y::StridedVector{Ty}, A::StridedMatrix, x::AbstractSparseVector{Tx}) where {Tx,Ty} = mul!(y, A, x) -end - -# A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/rowvector.jl, to deprecate -@eval Base.LinAlg begin - A_rdiv_Bt(rowvec::RowVector, mat::AbstractMatrix) = /(rowvec, Transpose(mat)) - A_rdiv_Bc(rowvec::RowVector, mat::AbstractMatrix) = /(rowvec, Adjoint(mat)) - At_ldiv_B(mat::AbstractMatrix, rowvec::RowVector) = \(Transpose(mat), rowvec) - Ac_ldiv_B(mat::AbstractMatrix, rowvec::RowVector) = \(Adjoint(mat), rowvec) - Ac_mul_B(u::RowVector, v::AbstractVector) = *(Adjoint(u), v) - Ac_mul_B(vec::AbstractVector, mat::AbstractMatrix) = *(Adjoint(vec), mat) - Ac_mul_B(rowvec1::RowVector, rowvec2::RowVector) = *(Adjoint(rowvec1), rowvec2) - Ac_mul_B(vec::AbstractVector, rowvec::RowVector) = *(Adjoint(vec), rowvec) - Ac_mul_B(vec1::AbstractVector, vec2::AbstractVector) = *(Adjoint(vec1), vec2) - Ac_mul_Bc(rowvec::RowVector, vec::AbstractVector) = *(Adjoint(rowvec), Adjoint(vec)) - Ac_mul_Bc(vec::AbstractVector, mat::AbstractMatrix) = *(Adjoint(vec), Adjoint(mat)) - Ac_mul_Bc(rowvec1::RowVector, rowvec2::RowVector) = *(Adjoint(rowvec1), Adjoint(rowvec2)) - Ac_mul_Bc(vec::AbstractVector, rowvec::RowVector) = *(Adjoint(vec), Adjoint(rowvec)) - Ac_mul_Bc(vec::AbstractVector, rowvec::AbstractVector) = *(Adjoint(vec), Adjoint(rowvec)) - Ac_mul_Bc(mat::AbstractMatrix, rowvec::RowVector) = *(Adjoint(mat), Adjoint(rowvec)) - A_mul_Bc(u::RowVector, v::AbstractVector) = *(u, Adjoint(v)) - A_mul_Bc(rowvec::RowVector, mat::AbstractMatrix) = *(rowvec, Adjoint(mat)) - A_mul_Bc(rowvec1::RowVector, rowvec2::RowVector) = *(rowvec1, Adjoint(rowvec2)) - A_mul_Bc(vec::AbstractVector, rowvec::RowVector) = *(vec, Adjoint(rowvec)) - A_mul_Bc(vec1::AbstractVector, vec2::AbstractVector) = *(vec1, Adjoint(vec2)) - A_mul_Bc(mat::AbstractMatrix, rowvec::RowVector) = *(mat, Adjoint(rowvec)) - At_mul_B(v::RowVector, u::AbstractVector) = *(Transpose(v), u) - At_mul_B(vec::AbstractVector, mat::AbstractMatrix) = *(Transpose(vec), mat) - At_mul_B(rowvec1::RowVector, rowvec2::RowVector) = *(Transpose(rowvec1), rowvec2) - At_mul_B(vec::AbstractVector, rowvec::RowVector) = *(Transpose(vec), rowvec) - At_mul_B(vec1::AbstractVector{T}, vec2::AbstractVector{T}) where {T<:Real} = *(Transpose(vec1), vec2) - At_mul_B(vec1::AbstractVector, vec2::AbstractVector) = *(Transpose(vec1), vec2) - At_mul_Bt(rowvec::RowVector, vec::AbstractVector) = *(Transpose(rowvec), Transpose(vec)) - At_mul_Bt(vec::AbstractVector, mat::AbstractMatrix) = *(Transpose(vec), Transpose(mat)) - At_mul_Bt(rowvec1::RowVector, rowvec2::RowVector) = *(Transpose(rowvec1), Transpose(rowvec2)) - At_mul_Bt(vec::AbstractVector, rowvec::RowVector) = *(Transpose(vec), Transpose(rowvec)) - At_mul_Bt(vec::AbstractVector, rowvec::AbstractVector) = *(Transpose(vec), Transpose(rowvec)) - At_mul_Bt(mat::AbstractMatrix, rowvec::RowVector) = *(Transpose(mat), Transpose(rowvec)) - A_mul_Bt(v::RowVector, A::AbstractVector) = *(v, Transpose(A)) - A_mul_Bt(rowvec::RowVector, mat::AbstractMatrix) = *(rowvec, Transpose(mat)) - A_mul_Bt(rowvec1::RowVector, rowvec2::RowVector) = *(rowvec1, Transpose(rowvec2)) - A_mul_Bt(vec::AbstractVector, rowvec::RowVector) = *(vec, Transpose(rowvec)) - A_mul_Bt(vec1::AbstractVector, vec2::AbstractVector) = *(vec1, Transpose(vec2)) - A_mul_Bt(mat::AbstractMatrix, rowvec::RowVector) = *(mat, Transpose(rowvec)) -end - -# A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/givens.jl, to deprecate -@eval Base.LinAlg begin - A_mul_Bc!(A::AbstractMatrix, R::Rotation) = mul!(A, Adjoint(R)) - A_mul_B!(R::Rotation, A::AbstractMatrix) = mul!(R, A) - A_mul_B!(G::Givens, R::Rotation) = mul!(G, R) - A_mul_Bc!(A::AbstractMatrix, G::Givens) = mul!(A, Adjoint(G)) - A_mul_B!(G::Givens, A::AbstractVecOrMat) = mul!(G, A) - A_mul_B!(G1::Givens, G2::Givens) = mul!(G1, G2) - A_mul_Bc(A::AbstractVecOrMat{T}, R::AbstractRotation{S}) where {T,S} = *(A, Adjoint(R)) -end - -# A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/operators.jl, to deprecate -@eval Base begin - using Base.LinAlg: Adjoint, Transpose - """ - Ac_ldiv_Bt(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ`` \\ ``Bᵀ``. - """ - Ac_ldiv_Bt(a,b) = \(Adjoint(a), Transpose(b)) - """ - At_ldiv_Bt(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ`` \\ ``Bᵀ``. - """ - At_ldiv_Bt(a,b) = \(Transpose(a), Transpose(b)) - """ - A_ldiv_Bt(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``A`` \\ ``Bᵀ``. - """ - A_ldiv_Bt(a,b) = \(a, Transpose(b)) - """ - At_ldiv_B(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ`` \\ ``B``. - """ - At_ldiv_B(a,b) = \(Transpose(a), b) - """ - Ac_ldiv_Bc(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ`` \\ ``Bᴴ``. - """ - Ac_ldiv_Bc(a,b) = \(Adjoint(a), Adjoint(b)) - """ - A_ldiv_Bc(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``A`` \\ ``Bᴴ``. - """ - A_ldiv_Bc(a,b) = \(a, Adjoint(b)) - """ - Ac_ldiv_B(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ`` \\ ``B``. - """ - Ac_ldiv_B(a,b) = \(Adjoint(a), b) - """ - At_rdiv_Bt(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ / Bᵀ``. - """ - At_rdiv_Bt(a,b) = /(Transpose(a), Transpose(b)) - """ - A_rdiv_Bt(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``A / Bᵀ``. - """ - A_rdiv_Bt(a,b) = /(a, Transpose(b)) - """ - At_rdiv_B(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ / B``. - """ - At_rdiv_B(a,b) = /(Transpose(a), b) - """ - Ac_rdiv_Bc(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ / Bᴴ``. - """ - Ac_rdiv_Bc(a,b) = /(Adjoint(a), Adjoint(b)) - """ - A_rdiv_Bc(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``A / Bᴴ``. - """ - A_rdiv_Bc(a,b) = /(a, Adjoint(b)) - """ - Ac_rdiv_B(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ / B``. - """ - Ac_rdiv_B(a,b) = /(Adjoint(a), b) - """ - At_mul_Bt(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ⋅Bᵀ``. - """ - At_mul_Bt(a,b) = *(Transpose(a), Transpose(b)) - """ - A_mul_Bt(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``A⋅Bᵀ``. - """ - A_mul_Bt(a,b) = *(a, Transpose(b)) - """ - At_mul_B(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ⋅B``. - """ - At_mul_B(a,b) = *(Transpose(a), b) - """ - Ac_mul_Bc(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ Bᴴ``. - """ - Ac_mul_Bc(a,b) = *(Adjoint(a), Adjoint(b)) - """ - A_mul_Bc(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``A⋅Bᴴ``. - """ - A_mul_Bc(a,b) = *(a, Adjoint(b)) - """ - Ac_mul_B(A, B) - - For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ⋅B``. - """ - Ac_mul_B(a,b) = *(Adjoint(a), b) + @deprecate Ac_mul_B(A::SparseMatrixCSC, x::AbstractSparseVector) (*)(Adjoint(A), x) + @deprecate At_mul_B(A::SparseMatrixCSC, x::AbstractSparseVector) (*)(Transpose(A), x) + @deprecate Ac_mul_B!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Number, y::StridedVector) mul!(α, Adjoint(A), x, β, y) + @deprecate Ac_mul_B!(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) where {Tx,Ty} mul!(y, Adjoint(A), x) + @deprecate At_mul_B!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Number, y::StridedVector) mul!(α, Transpose(A), x, β, y) + @deprecate At_mul_B!(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) where {Tx,Ty} mul!(y, Transpose(A), x) + @deprecate A_mul_B!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Number, y::StridedVector) mul!(α, A, x, β, y) + @deprecate A_mul_B!(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) where {Tx,Ty} mul!(y, A, x) + @deprecate At_mul_B!(α::Number, A::StridedMatrix, x::AbstractSparseVector, β::Number, y::StridedVector) mul!(α, Transpose(A), x, β, y) + @deprecate At_mul_B!(y::StridedVector{Ty}, A::StridedMatrix, x::AbstractSparseVector{Tx}) where {Tx,Ty} mul!(y, Transpose(A), x) + @deprecate At_mul_B(A::StridedMatrix{Ta}, x::AbstractSparseVector{Tx}) where {Ta,Tx} (*)(Transpose(A), x) + @deprecate A_mul_B!(α::Number, A::StridedMatrix, x::AbstractSparseVector, β::Number, y::StridedVector) mul!(α, A, x, β, y) + @deprecate A_mul_B!(y::StridedVector{Ty}, A::StridedMatrix, x::AbstractSparseVector{Tx}) where {Tx,Ty} mul!(y, A, x) 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 diff --git a/base/exports.jl b/base/exports.jl index 2da4595fc35ca..9dd7198dca743 100644 --- a/base/exports.jl +++ b/base/exports.jl @@ -220,34 +220,6 @@ export :, =>, ∘, - A_ldiv_B!, - A_ldiv_Bc, - A_ldiv_Bt, - A_mul_B!, - A_mul_Bc, - A_mul_Bc!, - A_mul_Bt, - A_mul_Bt!, - A_rdiv_Bc, - A_rdiv_Bt, - Ac_ldiv_B, - Ac_ldiv_B!, - Ac_ldiv_Bc, - Ac_mul_B, - Ac_mul_B!, - Ac_mul_Bc, - Ac_mul_Bc!, - Ac_rdiv_B, - Ac_rdiv_Bc, - At_ldiv_B, - At_ldiv_B!, - At_ldiv_Bt, - At_mul_B, - At_mul_B!, - At_mul_Bt, - At_mul_Bt!, - At_rdiv_B, - At_rdiv_Bt, # scalar math @evalpoly, diff --git a/base/linalg/linalg.jl b/base/linalg/linalg.jl index e5e36952ed6f2..2053130b77183 100644 --- a/base/linalg/linalg.jl +++ b/base/linalg/linalg.jl @@ -1,26 +1,5 @@ # This file is a part of Julia. License is MIT: https://julialang.org/license -# shims to maintain existence of names in Base module in A_mul_B deprecation process -function Ac_ldiv_Bt end -function At_ldiv_Bt end -function A_ldiv_Bt end -function At_ldiv_B end -function Ac_ldiv_Bc end -function A_ldiv_Bc end -function Ac_ldiv_B end -function At_rdiv_Bt end -function A_rdiv_Bt end -function At_rdiv_B end -function Ac_rdiv_Bc end -function A_rdiv_Bc end -function Ac_rdiv_B end -function At_mul_Bt end -function A_mul_Bt end -function At_mul_B end -function Ac_mul_Bc end -function A_mul_Bc end -function Ac_mul_B end - """ Linear algebra module. Provides array arithmetic, matrix factorizations and other linear algebra related @@ -29,8 +8,6 @@ functionality. module LinAlg import Base: \, /, *, ^, +, -, == -import Base: A_mul_Bt, At_ldiv_Bt, A_rdiv_Bc, At_ldiv_B, Ac_mul_Bc, A_mul_Bc, Ac_mul_B, - Ac_ldiv_B, Ac_ldiv_Bc, At_mul_Bt, A_rdiv_Bt, At_mul_B import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, asec, asech, asin, asinh, atan, atanh, axes, big, broadcast, ceil, conj, convert, copy, copyto!, cos, cosh, cot, coth, csc, csch, eltype, exp, findmax, findmin, fill!, floor, getindex, hcat, @@ -171,34 +148,6 @@ export # Operators \, /, - A_ldiv_B!, - A_ldiv_Bc, - A_ldiv_Bt, - A_mul_B!, - A_mul_Bc, - A_mul_Bc!, - A_mul_Bt, - A_mul_Bt!, - A_rdiv_Bc, - A_rdiv_Bt, - Ac_ldiv_B, - Ac_ldiv_Bc, - Ac_ldiv_B!, - Ac_mul_B, - Ac_mul_B!, - Ac_mul_Bc, - Ac_mul_Bc!, - Ac_rdiv_B, - Ac_rdiv_Bc, - At_ldiv_B, - At_ldiv_Bt, - At_ldiv_B!, - At_mul_B, - At_mul_B!, - At_mul_Bt, - At_mul_Bt!, - At_rdiv_B, - At_rdiv_Bt, # Constants I @@ -261,16 +210,37 @@ function char_uplo(uplo::Symbol) end end -# shims to maintain existence of names in LinAlg module in A_mul_B deprecation process -function A_mul_B! end -function Ac_mul_B! end -function Ac_mul_B! end -function At_mul_B! end -function A_ldiv_B! end -function At_ldiv_B! end -function Ac_ldiv_B! end -function A_rdiv_B! end -function A_rdiv_Bc! end +""" + ldiv!([Y,] A, B) -> Y + +Compute `A \\ B` in-place and store the result in `Y`, returning the result. +If only two arguments are passed, then `ldiv!(A, B)` overwrites `B` with +the result. + +The argument `A` should *not* be a matrix. Rather, instead of matrices it should be a +factorization object (e.g. produced by [`factorize`](@ref) or [`cholfact`](@ref)). +The reason for this is that factorization itself is both expensive and typically allocates memory +(although it can also be done in-place via, e.g., [`lufact!`](@ref)), +and performance-critical situations requiring `ldiv!` usually also require fine-grained +control over the factorization of `A`. +""" +ldiv!(Y, A, B) + +""" + rdiv!([Y,] A, B) -> Y + +Compute `A / B` in-place and store the result in `Y`, returning the result. +If only two arguments are passed, then `rdiv!(A, B)` overwrites `A` with +the result. + +The argument `B` should *not* be a matrix. Rather, instead of matrices it should be a +factorization object (e.g. produced by [`factorize`](@ref) or [`cholfact`](@ref)). +The reason for this is that factorization itself is both expensive and typically allocates memory +(although it can also be done in-place via, e.g., [`lufact!`](@ref)), +and performance-critical situations requiring `rdiv!` usually also require fine-grained +control over the factorization of `B`. +""" +rdiv!(Y, A, B) copy_oftype(A::AbstractArray{T}, ::Type{T}) where {T} = copy(A) copy_oftype(A::AbstractArray{T,N}, ::Type{S}) where {T,N,S} = convert(AbstractArray{S,N}, A) diff --git a/base/sparse/sparse.jl b/base/sparse/sparse.jl index 3cad4648c8c06..8c9133aabe6ab 100644 --- a/base/sparse/sparse.jl +++ b/base/sparse/sparse.jl @@ -10,10 +10,7 @@ using Base.Sort: Forward using Base.LinAlg: AbstractTriangular, PosDefException, fillstored! import Base: +, -, *, \, /, &, |, xor, == -import Base: A_mul_B!, Ac_mul_B, Ac_mul_B!, At_mul_B, At_mul_B! -import Base: A_mul_Bc, A_mul_Bt, Ac_mul_Bc, At_mul_Bt -import Base: At_ldiv_B, Ac_ldiv_B, A_ldiv_B! -import Base.LinAlg: At_ldiv_B!, Ac_ldiv_B!, A_rdiv_B!, A_rdiv_Bc!, mul!, ldiv!, rdiv! +import Base.LinAlg: mul!, ldiv!, rdiv! import Base: @get!, acos, acosd, acot, acotd, acsch, asech, asin, asind, asinh, atan, atand, atanh, broadcast!, chol, conj!, cos, cosc, cosd, cosh, cospi, cot, diff --git a/doc/src/manual/linear-algebra.md b/doc/src/manual/linear-algebra.md index 8d8d4c24203ab..e8131776759dc 100644 --- a/doc/src/manual/linear-algebra.md +++ b/doc/src/manual/linear-algebra.md @@ -138,13 +138,7 @@ julia> sB\x -1.1086956521739126 -1.4565217391304346 ``` -The `\` operation here performs the linear solution. Julia's parser provides convenient dispatch -to specialized methods for the *transpose* of a matrix left-divided by a vector, or for the various combinations -of transpose operations in matrix-matrix solutions. Many of these are further specialized for certain special -matrix types. For example, `A\B` will end up calling [`Base.LinAlg.A_ldiv_B!`](@ref) while `A'\B` will end up calling -[`Base.LinAlg.Ac_ldiv_B`](@ref), even though we used the same left-division operator. This works for matrices too: `A.'\B.'` -would call [`Base.LinAlg.At_ldiv_Bt`](@ref). The left-division operator is pretty powerful and it's easy to write compact, -readable code that is flexible enough to solve all sorts of systems of linear equations. +The `\` operation here performs the linear solution. The left-division operator is pretty powerful and it's easy to write compact, readable code that is flexible enough to solve all sorts of systems of linear equations. ## Special matrices diff --git a/doc/src/stdlib/linalg.md b/doc/src/stdlib/linalg.md index 571a039e30753..a1b3ae0e292d5 100644 --- a/doc/src/stdlib/linalg.md +++ b/doc/src/stdlib/linalg.md @@ -143,38 +143,15 @@ Base.LinAlg.stride1 ## Low-level matrix operations -Matrix operations involving transpositions operations like `A' \ B` are converted by the Julia -parser into calls to specially named functions like [`Ac_ldiv_B`](@ref). If you want to overload these -operations for your own types, then it is useful to know the names of these functions. - -Also, in many cases there are in-place versions of matrix operations that allow you to supply +In many cases there are in-place versions of matrix operations that allow you to supply a pre-allocated output vector or matrix. This is useful when optimizing critical code in order to avoid the overhead of repeated allocations. These in-place operations are suffixed with `!` -below (e.g. [`A_mul_B!`](@ref)) according to the usual Julia convention. +below (e.g. `mul!`) according to the usual Julia convention. ```@docs -Base.LinAlg.A_ldiv_B! -Base.A_ldiv_Bc -Base.A_ldiv_Bt -Base.LinAlg.A_mul_B! -Base.A_mul_Bc -Base.A_mul_Bt -Base.A_rdiv_Bc -Base.A_rdiv_Bt -Base.Ac_ldiv_B -Base.LinAlg.Ac_ldiv_B! -Base.Ac_ldiv_Bc -Base.Ac_mul_B -Base.Ac_mul_Bc -Base.Ac_rdiv_B -Base.Ac_rdiv_Bc -Base.At_ldiv_B -Base.LinAlg.At_ldiv_B! -Base.At_ldiv_Bt -Base.At_mul_B -Base.At_mul_Bt -Base.At_rdiv_B -Base.At_rdiv_Bt +Base.LinAlg.mul! +Base.LinAlg.ldiv! +Base.LinAlg.rdiv! ``` ## BLAS Functions From 7c8068f0724be6b313509b3914b105c14e7cbad0 Mon Sep 17 00:00:00 2001 From: Sacha Verweij Date: Tue, 19 Dec 2017 19:19:53 -0800 Subject: [PATCH 2/3] Deprecate ConjArray as part of the ConjRowVector/RowVector implementation. --- base/deprecated.jl | 61 ++++++++++++++++++++++++++++++++++++++++ base/exports.jl | 1 - base/linalg/conjarray.jl | 36 ++---------------------- base/linalg/linalg.jl | 5 +--- test/choosetests.jl | 2 +- test/linalg/conjarray.jl | 40 -------------------------- 6 files changed, 65 insertions(+), 80 deletions(-) delete mode 100644 test/linalg/conjarray.jl diff --git a/base/deprecated.jl b/base/deprecated.jl index e6ed62f8b1b67..ad6e69fb08a1e 100644 --- a/base/deprecated.jl +++ b/base/deprecated.jl @@ -2248,6 +2248,67 @@ finalizer(f::Ptr{Cvoid}, o::Function) = invoke(finalizer, Tuple{Ptr{Cvoid}, Any} Base.@deprecate_binding broadcast_t broadcast false ", broadcast_t(f, ::Type{ElType}, shape, iter, As...)` should become `broadcast(f, Broadcast.DefaultArrayStyle{N}(), ElType, shape, As...))` (see the manual chapter Interfaces)" end + +### deprecations for lazier, less jazzy linalg transition in the next several blocks ### + +# deprecate ConjArray +# TODO: between 0.7 and 1.0 remove +# 1) the type definitions in base/linalg/conjarray.jl +# 2) the include("base/linalg/conjarray.jl") from base/linalg/linalg.jl +# 3) the file base/linalg/conjarray.jl itself +@eval Base.LinAlg begin + export ConjArray, ConjVector, ConjMatrix + + function ConjArray(a::AbstractArray{T,N}) where {T,N} + Base.depwarn(_ConjArray_depstring(), :ConjArray) + return ConjArray{conj_type(T),N,typeof(a)}(a) + end + function ConjVector(v::AbstractVector{T}) where {T} + Base.depwarn(_ConjArray_depstring(), :ConjArray) + return ConjArray{conj_type(T),1,typeof(v)}(v) + end + function ConjMatrix(m::AbstractMatrix{T}) where {T} + Base.depwarn(_ConjArray_depstring(), :ConjArray) + return ConjArray{conj_type(T),2,typeof(m)}(m) + end + + _ConjArray_depstring() = string("`ConjRowVector` and `RowVector` have been deprecated in favor ", + "of `Adjoint` and `Transpose`, and, as part of the implementation of `ConjRowVector`", + "/`RowVector`, `ConjArray`s have been deprecated as well. Please see 0.7's NEWS.md ", + "for a more detailed explanation of the associated changes.") + + # This type can cause the element type to change under conjugation - e.g. an array of complex arrays. + @inline conj_type(x) = conj_type(typeof(x)) + @inline conj_type(::Type{T}) where {T} = promote_op(conj, T) + + @inline parent(c::ConjArray) = c.parent + @inline parent_type(c::ConjArray) = parent_type(typeof(c)) + @inline parent_type(::Type{ConjArray{T,N,A}}) where {T,N,A} = A + + @inline size(a::ConjArray) = size(a.parent) + IndexStyle(::CA) where {CA<:ConjArray} = IndexStyle(parent_type(CA)) + IndexStyle(::Type{CA}) where {CA<:ConjArray} = IndexStyle(parent_type(CA)) + + @propagate_inbounds getindex(a::ConjArray{T,N}, i::Int) where {T,N} = conj(getindex(a.parent, i)) + @propagate_inbounds getindex(a::ConjArray{T,N}, i::Vararg{Int,N}) where {T,N} = conj(getindex(a.parent, i...)) + @propagate_inbounds setindex!(a::ConjArray{T,N}, v, i::Int) where {T,N} = setindex!(a.parent, conj(v), i) + @propagate_inbounds setindex!(a::ConjArray{T,N}, v, i::Vararg{Int,N}) where {T,N} = setindex!(a.parent, conj(v), i...) + + @inline similar(a::ConjArray, ::Type{T}, dims::Dims{N}) where {T,N} = similar(parent(a), T, dims) + + # Currently, this is default behavior for RowVector only + @inline conj(a::ConjArray) = parent(a) + + # Helper functions, currently used by RowVector + @inline _conj(a::AbstractArray) = ConjArray(a) + @inline _conj(a::AbstractArray{T}) where {T<:Real} = a + @inline _conj(a::ConjArray) = parent(a) + @inline _conj(a::ConjArray{T}) where {T<:Real} = parent(a) +end +@eval Base begin + export ConjArray +end + # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/operators.jl, to deprecate @deprecate Ac_ldiv_Bt(a,b) (\)(Adjoint(a), Transpose(b)) @deprecate At_ldiv_Bt(a,b) (\)(Transpose(a), Transpose(b)) diff --git a/base/exports.jl b/base/exports.jl index 9dd7198dca743..84be69272d661 100644 --- a/base/exports.jl +++ b/base/exports.jl @@ -47,7 +47,6 @@ export ComplexF64, ComplexF32, ComplexF16, - ConjArray, ConjVector, ConjMatrix, DenseMatrix, diff --git a/base/linalg/conjarray.jl b/base/linalg/conjarray.jl index 2f743cdf403b8..3ef5f2c4db6ae 100644 --- a/base/linalg/conjarray.jl +++ b/base/linalg/conjarray.jl @@ -1,5 +1,7 @@ # This file is a part of Julia. License is MIT: https://julialang.org/license +# TODO: remove this type stub between 0.7 and 1.0 + """ ConjArray(array) @@ -19,39 +21,5 @@ julia> ConjArray([1+im 0; 0 1-im]) struct ConjArray{T,N,A<:AbstractArray} <: AbstractArray{T,N} parent::A end - -@inline ConjArray(a::AbstractArray{T,N}) where {T,N} = ConjArray{conj_type(T),N,typeof(a)}(a) - const ConjVector{T,V<:AbstractVector} = ConjArray{T,1,V} -@inline ConjVector(v::AbstractVector{T}) where {T} = ConjArray{conj_type(T),1,typeof(v)}(v) - const ConjMatrix{T,M<:AbstractMatrix} = ConjArray{T,2,M} -@inline ConjMatrix(m::AbstractMatrix{T}) where {T} = ConjArray{conj_type(T),2,typeof(m)}(m) - -# This type can cause the element type to change under conjugation - e.g. an array of complex arrays. -@inline conj_type(x) = conj_type(typeof(x)) -@inline conj_type(::Type{T}) where {T} = promote_op(conj, T) - -@inline parent(c::ConjArray) = c.parent -@inline parent_type(c::ConjArray) = parent_type(typeof(c)) -@inline parent_type(::Type{ConjArray{T,N,A}}) where {T,N,A} = A - -@inline size(a::ConjArray) = size(a.parent) -IndexStyle(::CA) where {CA<:ConjArray} = IndexStyle(parent_type(CA)) -IndexStyle(::Type{CA}) where {CA<:ConjArray} = IndexStyle(parent_type(CA)) - -@propagate_inbounds getindex(a::ConjArray{T,N}, i::Int) where {T,N} = conj(getindex(a.parent, i)) -@propagate_inbounds getindex(a::ConjArray{T,N}, i::Vararg{Int,N}) where {T,N} = conj(getindex(a.parent, i...)) -@propagate_inbounds setindex!(a::ConjArray{T,N}, v, i::Int) where {T,N} = setindex!(a.parent, conj(v), i) -@propagate_inbounds setindex!(a::ConjArray{T,N}, v, i::Vararg{Int,N}) where {T,N} = setindex!(a.parent, conj(v), i...) - -@inline similar(a::ConjArray, ::Type{T}, dims::Dims{N}) where {T,N} = similar(parent(a), T, dims) - -# Currently, this is default behavior for RowVector only -@inline conj(a::ConjArray) = parent(a) - -# Helper functions, currently used by RowVector -@inline _conj(a::AbstractArray) = ConjArray(a) -@inline _conj(a::AbstractArray{T}) where {T<:Real} = a -@inline _conj(a::ConjArray) = parent(a) -@inline _conj(a::ConjArray{T}) where {T<:Real} = parent(a) diff --git a/base/linalg/linalg.jl b/base/linalg/linalg.jl index 2053130b77183..0c7782e4d66db 100644 --- a/base/linalg/linalg.jl +++ b/base/linalg/linalg.jl @@ -29,9 +29,6 @@ export Adjoint, Transpose, RowVector, - ConjArray, - ConjVector, - ConjMatrix, SymTridiagonal, Tridiagonal, Bidiagonal, @@ -246,8 +243,8 @@ copy_oftype(A::AbstractArray{T}, ::Type{T}) where {T} = copy(A) copy_oftype(A::AbstractArray{T,N}, ::Type{S}) where {T,N,S} = convert(AbstractArray{S,N}, A) include("adjtrans.jl") -include("conjarray.jl") include("transpose.jl") +include("conjarray.jl") include("rowvector.jl") include("exceptions.jl") diff --git a/test/choosetests.jl b/test/choosetests.jl index aea130dd8e9f0..2ca50d182bf88 100644 --- a/test/choosetests.jl +++ b/test/choosetests.jl @@ -125,7 +125,7 @@ function choosetests(choices = []) "linalg/diagonal", "linalg/pinv", "linalg/givens", "linalg/cholesky", "linalg/lu", "linalg/symmetric", "linalg/generic", "linalg/uniformscaling", "linalg/lq", - "linalg/hessenberg", "linalg/rowvector", "linalg/conjarray", + "linalg/hessenberg", "linalg/rowvector", "linalg/blas", "linalg/adjtrans"] if "linalg" in skip_tests diff --git a/test/linalg/conjarray.jl b/test/linalg/conjarray.jl deleted file mode 100644 index 99663f9a12684..0000000000000 --- a/test/linalg/conjarray.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -@testset "Core" begin - m = [1+im 2; 2 4-im] - cm = ConjMatrix(m) - @test cm[1,1] == 1-im - @test cm[1] == 1-im - @test trace(cm*m) == 27 - @test adjoint(cm) == m - - cm[:,2] = [3; 3-im] #setindex! with a vector - @test conj(cm) == [1+im 3; 2 3+im] - - v = [[1+im], [1-im]] - cv = ConjVector(v) - @test cv[1] == [1-im] -end - -@testset "RowVector conjugates" begin - # these definitions are what adjoint(...) and transpose(...) meant - # meant prior to the Adjoint/Transpose transition, and the tests - # below are re-expressed in them to shield them against changes - # to adjoint(...), transpose(...), .', ', and A[ct]_(mul|ldiv|rdiv)_B[ct] - using Base.LinAlg: _conj, ConjRowVector - rvadjoint(v::AbstractVector) = RowVector(_conj(v)) - rvtranspose(v::AbstractVector) = RowVector(v) - rvadjoint(v::RowVector) = conj(v.vec) - rvadjoint(v::RowVector{<:Real}) = v.vec - rvtranspose(v::RowVector) = v.vec - rvtranspose(v::ConjRowVector) = copy(v.vec) - - v = [1+im, 1-im] - rv = rvadjoint(v) - @test (parent(rv) isa ConjArray) - @test rvadjoint(rv) === v - - # Currently, view behavior defaults to only RowVectors. - @test isa(rvtranspose(rvadjoint(v)), Vector) - @test isa(rvadjoint(rvtranspose(v)), Vector) -end From 3ed7386682fc02aed5473eb96eff74e1022332a3 Mon Sep 17 00:00:00 2001 From: Sacha Verweij Date: Tue, 19 Dec 2017 20:27:02 -0800 Subject: [PATCH 3/3] Deprecate ConjRowVector/RowVector in favor of Adjoint/Transpose. --- base/deprecated.jl | 282 +++++++++++++++++++++++++++++++- base/exports.jl | 1 - base/linalg/linalg.jl | 1 - base/linalg/rowvector.jl | 241 +-------------------------- base/sparse/sparsevector.jl | 8 +- test/choosetests.jl | 3 +- test/linalg/cholesky.jl | 2 - test/linalg/rowvector.jl | 318 ------------------------------------ 8 files changed, 283 insertions(+), 573 deletions(-) delete mode 100644 test/linalg/rowvector.jl diff --git a/base/deprecated.jl b/base/deprecated.jl index ad6e69fb08a1e..858ab9c6c699b 100644 --- a/base/deprecated.jl +++ b/base/deprecated.jl @@ -2219,12 +2219,6 @@ end @deprecate chol!(x::Number, uplo) chol(x) false end -# deprecate RowVector{T}(shape...) constructors to RowVector{T}(uninitialized, shape...) equivalents -@deprecate RowVector{T}(n::Int) where {T} RowVector{T}(uninitialized, n) -@deprecate RowVector{T}(n1::Int, n2::Int) where {T} RowVector{T}(uninitialized, n1, n2) -@deprecate RowVector{T}(n::Tuple{Int}) where {T} RowVector{T}(uninitialized, n) -@deprecate RowVector{T}(n::Tuple{Int,Int}) where {T} RowVector{T}(uninitialized, n) - @deprecate cumsum(A::AbstractArray) cumsum(A, 1) @deprecate cumprod(A::AbstractArray) cumprod(A, 1) @@ -2309,6 +2303,282 @@ end export ConjArray end +# deprecate ConjRowVector/RowVector +# TODO: between 0.7 and 1.0 remove +# 1) the type definitions in base/linalg/rowvector.jl +# 2) the include("base/linalg/rowvector.jl") from base/linalg/linalg.jl +# 3) the file base/linalg/rowvector.jl itself +# 4) the RowVectors in the Unions in base/sparse/sparsevector.jl around lines 995, 1010, 1011, and 1012 +@eval Base.LinAlg begin + export RowVector + + _RowVector_depstring() = string("`ConjRowVector` and `RowVector` have been deprecated in favor ", + "of `Adjoint` and `Transpose`. Please see 0.7's NEWS.md for a more detailed explanation ", + "of the associated changes.") + + @inline check_types(::Type{T1}, ::AbstractVector{T2}) where {T1,T2} = check_types(T1, T2) + @pure check_types(::Type{T1}, ::Type{T2}) where {T1,T2} = T1 === transpose_type(T2) ? nothing : + error("Element type mismatch. Tried to create a `RowVector{$T1}` from an `AbstractVector{$T2}`") + + # The element type may be transformed as transpose is recursive + @inline transpose_type(::Type{T}) where {T} = promote_op(transpose, T) + + # Constructors that take a vector + function RowVector(vec::AbstractVector{T}) where {T} + Base.depwarn(_RowVector_depstring(), :RowVector) + return RowVector{transpose_type(T),typeof(vec)}(vec) + end + function RowVector{T}(vec::AbstractVector{T}) where {T} + Base.depwarn(_RowVector_depstring(), :RowVector) + return RowVector{T,typeof(vec)}(vec) + end + + # Constructors that take a size and default to Array + function RowVector{T}(::Uninitialized, n::Int) where {T} + Base.depwarn(_RowVector_depstring(), :RowVector) + return RowVector{T}(Vector{transpose_type(T)}(uninitialized, n)) + end + function RowVector{T}(::Uninitialized, n1::Int, n2::Int) where {T} + Base.depwarn(_RowVector_depstring(), :RowVector) + return n1 == 1 ? RowVector{T}(Vector{transpose_type(T)}(uninitialized, n2)) : + error("RowVector expects 1×N size, got ($n1,$n2)") + end + function RowVector{T}(::Uninitialized, n::Tuple{Int}) where {T} + Base.depwarn(_RowVector_depstring(), :RowVector) + return RowVector{T}(Vector{transpose_type(T)}(uninitialized, n[1])) + end + function RowVector{T}(::Uninitialized, n::Tuple{Int,Int}) where {T} + Base.depwarn(_RowVector_depstring(), :RowVector) + return n[1] == 1 ? RowVector{T}(Vector{transpose_type(T)}(uninitialized, n[2])) : + error("RowVector expects 1×N size, got $n") + end + + # Conversion of underlying storage + convert(::Type{RowVector{T,V}}, rowvec::RowVector) where {T,V<:AbstractVector} = + RowVector{T,V}(convert(V,rowvec.vec)) + + # similar tries to maintain the RowVector wrapper and the parent type + @inline similar(rowvec::RowVector) = RowVector(similar(parent(rowvec))) + @inline similar(rowvec::RowVector, ::Type{T}) where {T} = RowVector(similar(parent(rowvec), transpose_type(T))) + + # Resizing similar currently loses its RowVector property. + @inline similar(rowvec::RowVector, ::Type{T}, dims::Dims{N}) where {T,N} = similar(parent(rowvec), T, dims) + + # Basic methods + + # replaced in the Adjoint/Transpose transition + # """ + # transpose(v::AbstractVector) + # + # The transposition operator (`.'`). + # + # # Examples + # ```jldoctest + # julia> v = [1,2,3] + # 3-element Array{Int64,1}: + # 1 + # 2 + # 3 + # + # julia> transpose(v) + # 1×3 RowVector{Int64,Array{Int64,1}}: + # 1 2 3 + # ``` + # """ + # @inline transpose(vec::AbstractVector) = RowVector(vec) + # @inline adjoint(vec::AbstractVector) = RowVector(_conj(vec)) + + # methods necessary to preserve RowVector's behavior through the Adjoint/Transpose transition + rvadjoint(v::AbstractVector) = RowVector(_conj(v)) + rvtranspose(v::AbstractVector) = RowVector(v) + rvadjoint(v::RowVector) = conj(v.vec) + rvadjoint(v::RowVector{<:Real}) = v.vec + rvtranspose(v::RowVector) = v.vec + rvtranspose(v::ConjRowVector) = copy(v.vec) + rvadjoint(x) = adjoint(x) + rvtranspose(x) = transpose(x) + + @inline transpose(rowvec::RowVector) = rowvec.vec + @inline transpose(rowvec::ConjRowVector) = copy(rowvec.vec) # remove the ConjArray wrapper from any raw vector + @inline adjoint(rowvec::RowVector) = conj(rowvec.vec) + @inline adjoint(rowvec::RowVector{<:Real}) = rowvec.vec + + parent(rowvec::RowVector) = rowvec.vec + vec(rowvec::RowVector) = rowvec.vec + + """ + conj(v::RowVector) + + Return a [`ConjArray`](@ref) lazy view of the input, where each element is conjugated. + + # Examples + ```jldoctest + julia> v = RowVector([1+im, 1-im]) + 1×2 RowVector{Complex{Int64},Array{Complex{Int64},1}}: + 1+1im 1-1im + + julia> conj(v) + 1×2 RowVector{Complex{Int64},ConjArray{Complex{Int64},1,Array{Complex{Int64},1}}}: + 1-1im 1+1im + ``` + """ + @inline conj(rowvec::RowVector) = RowVector(_conj(rowvec.vec)) + @inline conj(rowvec::RowVector{<:Real}) = rowvec + + # AbstractArray interface + @inline length(rowvec::RowVector) = length(rowvec.vec) + @inline size(rowvec::RowVector) = (1, length(rowvec.vec)) + @inline size(rowvec::RowVector, d) = ifelse(d==2, length(rowvec.vec), 1) + @inline axes(rowvec::RowVector) = (Base.OneTo(1), axes(rowvec.vec)[1]) + @inline axes(rowvec::RowVector, d) = ifelse(d == 2, axes(rowvec.vec)[1], Base.OneTo(1)) + IndexStyle(::RowVector) = IndexLinear() + IndexStyle(::Type{<:RowVector}) = IndexLinear() + + @propagate_inbounds getindex(rowvec::RowVector, i::Int) = rvtranspose(rowvec.vec[i]) + @propagate_inbounds setindex!(rowvec::RowVector, v, i::Int) = (setindex!(rowvec.vec, rvtranspose(v), i); rowvec) + + # Keep a RowVector where appropriate + @propagate_inbounds getindex(rowvec::RowVector, ::Colon, i::Int) = rvtranspose.(rowvec.vec[i:i]) + @propagate_inbounds getindex(rowvec::RowVector, ::Colon, inds::AbstractArray{Int}) = RowVector(rowvec.vec[inds]) + @propagate_inbounds getindex(rowvec::RowVector, ::Colon, ::Colon) = RowVector(rowvec.vec[:]) + + # helper function for below + @inline to_vec(rowvec::RowVector) = map(rvtranspose, rvtranspose(rowvec)) + @inline to_vec(x::Number) = x + @inline to_vecs(rowvecs...) = (map(to_vec, rowvecs)...,) + + # map: Preserve the RowVector by un-wrapping and re-wrapping, but note that `f` + # expects to operate within the transposed domain, so to_vec transposes the elements + @inline map(f, rowvecs::RowVector...) = RowVector(map(rvtranspose∘f, to_vecs(rowvecs...)...)) + + # broacast (other combinations default to higher-dimensional array) + @inline broadcast(f, rowvecs::Union{Number,RowVector}...) = + RowVector(broadcast(transpose∘f, to_vecs(rowvecs...)...)) + + # Horizontal concatenation # + + @inline hcat(X::RowVector...) = rvtranspose(vcat(map(rvtranspose, X)...)) + @inline hcat(X::Union{RowVector,Number}...) = rvtranspose(vcat(map(rvtranspose, X)...)) + + @inline typed_hcat(::Type{T}, X::RowVector...) where {T} = + rvtranspose(typed_vcat(T, map(rvtranspose, X)...)) + @inline typed_hcat(::Type{T}, X::Union{RowVector,Number}...) where {T} = + rvtranspose(typed_vcat(T, map(rvtranspose, X)...)) + + # Multiplication # + + # inner product -> dot product specializations + @inline *(rowvec::RowVector{T}, vec::AbstractVector{T}) where {T<:Real} = dot(parent(rowvec), vec) + @inline *(rowvec::ConjRowVector{T}, vec::AbstractVector{T}) where {T<:Real} = dot(rvadjoint(rowvec), vec) + @inline *(rowvec::ConjRowVector, vec::AbstractVector) = dot(rvadjoint(rowvec), vec) + + # Generic behavior + @inline function *(rowvec::RowVector, vec::AbstractVector) + if length(rowvec) != length(vec) + throw(DimensionMismatch("A has dimensions $(size(rowvec)) but B has dimensions $(size(vec))")) + end + sum(@inbounds(return rowvec[i]*vec[i]) for i = 1:length(vec)) + end + @inline *(rowvec::RowVector, mat::AbstractMatrix) = rvtranspose(Transpose(mat) * rvtranspose(rowvec)) + *(::RowVector, ::RowVector) = throw(DimensionMismatch("Cannot multiply two transposed vectors")) + @inline *(vec::AbstractVector, rowvec::RowVector) = vec .* rowvec + *(vec::AbstractVector, rowvec::AbstractVector) = throw(DimensionMismatch("Cannot multiply two vectors")) + + # Transposed forms + *(::RowVector, ::Transpose{<:Any,<:AbstractVector}) = + throw(DimensionMismatch("Cannot multiply two transposed vectors")) + *(rowvec::RowVector, transmat::Transpose{<:Any,<:AbstractMatrix}) = + (mat = transmat.parent; rvtranspose(mat * rvtranspose(rowvec))) + *(rowvec1::RowVector, transrowvec2::Transpose{<:Any,<:RowVector}) = + (rowvec2 = transrowvec2.parent; rowvec1*rvtranspose(rowvec2)) + *(::AbstractVector, ::Transpose{<:Any,<:RowVector}) = + throw(DimensionMismatch("Cannot multiply two vectors")) + *(mat::AbstractMatrix, transrowvec::Transpose{<:Any,<:RowVector}) = + (rowvec = transrowvec.parent; mat * rvtranspose(rowvec)) + + *(transrowvec::Transpose{<:Any,<:RowVector}, transvec::Transpose{<:Any,<:AbstractVector}) = + rvtranspose(transrowvec.parent) * transpose(transvec.parent) + *(transrowvec1::Transpose{<:Any,<:RowVector}, transrowvec2::Transpose{<:Any,<:RowVector}) = + throw(DimensionMismatch("Cannot multiply two vectors")) + *(transvec::Transpose{<:Any,<:AbstractVector}, transrowvec::Transpose{<:Any,<:RowVector}) = + transpose(transvec.parent)*rvtranspose(transrowvec.parent) + *(transmat::Transpose{<:Any,<:AbstractMatrix}, transrowvec::Transpose{<:Any,<:RowVector}) = + transmat * rvtranspose(transrowvec.parent) + + *(::Transpose{<:Any,<:RowVector}, ::AbstractVector) = + throw(DimensionMismatch("Cannot multiply two vectors")) + *(transrowvec1::Transpose{<:Any,<:RowVector}, rowvec2::RowVector) = + rvtranspose(transrowvec1.parent) * rowvec2 + *(transvec::Transpose{<:Any,<:AbstractVector}, rowvec::RowVector) = + throw(DimensionMismatch("Cannot multiply two transposed vectors")) + + # Conjugated forms + *(::RowVector, ::Adjoint{<:Any,<:AbstractVector}) = + throw(DimensionMismatch("Cannot multiply two transposed vectors")) + *(rowvec::RowVector, adjmat::Adjoint{<:Any,<:AbstractMatrix}) = + rvadjoint(adjmat.parent * rvadjoint(rowvec)) + *(rowvec1::RowVector, adjrowvec2::Adjoint{<:Any,<:RowVector}) = + rowvec1 * rvadjoint(adjrowvec2.parent) + *(vec::AbstractVector, adjrowvec::Adjoint{<:Any,<:RowVector}) = + throw(DimensionMismatch("Cannot multiply two vectors")) + *(mat::AbstractMatrix, adjrowvec::Adjoint{<:Any,<:RowVector}) = + mat * rvadjoint(adjrowvec.parent) + + *(adjrowvec::Adjoint{<:Any,<:RowVector}, adjvec::Adjoint{<:Any,<:AbstractVector}) = + rvadjoint(adjrowvec.parent) * adjoint(adjvec.parent) + *(adjrowvec1::Adjoint{<:Any,<:RowVector}, adjrowvec2::Adjoint{<:Any,<:RowVector}) = + throw(DimensionMismatch("Cannot multiply two vectors")) + *(adjvec::Adjoint{<:Any,<:AbstractVector}, adjrowvec::Adjoint{<:Any,<:RowVector}) = + adjoint(adjvec.parent)*rvadjoint(adjrowvec.parent) + *(adjmat::Adjoint{<:Any,<:AbstractMatrix}, adjrowvec::Adjoint{<:Any,<:RowVector}) = + adjoint(adjmat.parent) * rvadjoint(adjrowvec.parent) + + *(::Adjoint{<:Any,<:RowVector}, ::AbstractVector) = throw(DimensionMismatch("Cannot multiply two vectors")) + *(adjrowvec1::Adjoint{<:Any,<:RowVector}, rowvec2::RowVector) = rvadjoint(adjrowvec1.parent) * rowvec2 + *(adjvec::Adjoint{<:Any,<:AbstractVector}, rowvec::RowVector) = throw(DimensionMismatch("Cannot multiply two transposed vectors")) + + # Pseudo-inverse + pinv(v::RowVector, tol::Real=0) = rvadjoint(pinv(rvadjoint(v), tol)) + + # Left Division # + + \(rowvec1::RowVector, rowvec2::RowVector) = pinv(rowvec1) * rowvec2 + \(mat::AbstractMatrix, rowvec::RowVector) = throw(DimensionMismatch("Cannot left-divide transposed vector by matrix")) + \(transmat::Transpose{<:Any,<:AbstractMatrix}, rowvec::RowVector) = + throw(DimensionMismatch("Cannot left-divide transposed vector by matrix")) + \(adjmat::Adjoint{<:Any,<:AbstractMatrix}, rowvec::RowVector) = + throw(DimensionMismatch("Cannot left-divide transposed vector by matrix")) + + # Right Division # + + @inline /(rowvec::RowVector, mat::AbstractMatrix) = rvtranspose(transpose(mat) \ rvtranspose(rowvec)) + /(rowvec::RowVector, transmat::Transpose{<:Any,<:AbstractMatrix}) = rvtranspose(transmat.parent \ rvtranspose(rowvec)) + /(rowvec::RowVector, adjmat::Adjoint{<:Any,<:AbstractMatrix}) = rvadjoint(adjmat.parent \ rvadjoint(rowvec)) + + + # definitions necessary for test/linalg/dense.jl to pass + # should be cleaned up / revised as necessary in the future + /(A::Number, B::Adjoint{<:Any,<:RowVector}) = /(A, rvadjoint(B.parent)) + /(A::Matrix, B::RowVector) = rvadjoint(rvadjoint(B) \ adjoint(A)) + + + # dismabiguation methods + *(A::Adjoint{<:Any,<:AbstractVector}, B::Transpose{<:Any,<:RowVector}) = adjoint(A.parent) * B + *(A::Adjoint{<:Any,<:AbstractMatrix}, B::Transpose{<:Any,<:RowVector}) = A * rvtranspose(B.parent) + *(A::Transpose{<:Any,<:AbstractVector}, B::Adjoint{<:Any,<:RowVector}) = transpose(A.parent) * B + *(A::Transpose{<:Any,<:AbstractMatrix}, B::Adjoint{<:Any,<:RowVector}) = A * rvadjoint(B.parent) +end +@eval Base begin + export RowVector +end +@eval Base.LinAlg begin + # deprecate RowVector{T}(shape...) constructors to RowVector{T}(uninitialized, shape...) equivalents + @deprecate RowVector{T}(n::Int) where {T} RowVector{T}(uninitialized, n) + @deprecate RowVector{T}(n1::Int, n2::Int) where {T} RowVector{T}(uninitialized, n1, n2) + @deprecate RowVector{T}(n::Tuple{Int}) where {T} RowVector{T}(uninitialized, n) + @deprecate RowVector{T}(n::Tuple{Int,Int}) where {T} RowVector{T}(uninitialized, n) +end + # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/operators.jl, to deprecate @deprecate Ac_ldiv_Bt(a,b) (\)(Adjoint(a), Transpose(b)) @deprecate At_ldiv_Bt(a,b) (\)(Transpose(a), Transpose(b)) diff --git a/base/exports.jl b/base/exports.jl index 84be69272d661..377461f00ef79 100644 --- a/base/exports.jl +++ b/base/exports.jl @@ -97,7 +97,6 @@ export RoundUp, Adjoint, Transpose, - RowVector, AbstractSerializer, SerializationState, Set, diff --git a/base/linalg/linalg.jl b/base/linalg/linalg.jl index 0c7782e4d66db..90a617ddfb24b 100644 --- a/base/linalg/linalg.jl +++ b/base/linalg/linalg.jl @@ -28,7 +28,6 @@ export # Types Adjoint, Transpose, - RowVector, SymTridiagonal, Tridiagonal, Bidiagonal, diff --git a/base/linalg/rowvector.jl b/base/linalg/rowvector.jl index 89170bc29fd72..73182b0a38c13 100644 --- a/base/linalg/rowvector.jl +++ b/base/linalg/rowvector.jl @@ -1,5 +1,7 @@ # This file is a part of Julia. License is MIT: https://julialang.org/license +# TODO: remove the type stubs below between 0.7 and 1.0 + """ RowVector(vector) @@ -57,243 +59,4 @@ struct RowVector{T,V<:AbstractVector} <: AbstractMatrix{T} new(v) end end - -@inline check_types(::Type{T1}, ::AbstractVector{T2}) where {T1,T2} = check_types(T1, T2) -@pure check_types(::Type{T1}, ::Type{T2}) where {T1,T2} = T1 === transpose_type(T2) ? nothing : - error("Element type mismatch. Tried to create a `RowVector{$T1}` from an `AbstractVector{$T2}`") - const ConjRowVector{T,CV<:ConjVector} = RowVector{T,CV} - -# The element type may be transformed as transpose is recursive -@inline transpose_type(::Type{T}) where {T} = promote_op(transpose, T) - -# Constructors that take a vector -@inline RowVector(vec::AbstractVector{T}) where {T} = RowVector{transpose_type(T),typeof(vec)}(vec) -@inline RowVector{T}(vec::AbstractVector{T}) where {T} = RowVector{T,typeof(vec)}(vec) - -# Constructors that take a size and default to Array -@inline RowVector{T}(::Uninitialized, n::Int) where {T} = - RowVector{T}(Vector{transpose_type(T)}(uninitialized, n)) -@inline RowVector{T}(::Uninitialized, n1::Int, n2::Int) where {T} = - n1 == 1 ? RowVector{T}(Vector{transpose_type(T)}(uninitialized, n2)) : - error("RowVector expects 1×N size, got ($n1,$n2)") -@inline RowVector{T}(::Uninitialized, n::Tuple{Int}) where {T} = - RowVector{T}(Vector{transpose_type(T)}(uninitialized, n[1])) -@inline RowVector{T}(::Uninitialized, n::Tuple{Int,Int}) where {T} = - n[1] == 1 ? RowVector{T}(Vector{transpose_type(T)}(uninitialized, n[2])) : - error("RowVector expects 1×N size, got $n") - -# Conversion of underlying storage -RowVector{T,V}(rowvec::RowVector) where {T,V<:AbstractVector} = - RowVector{T,V}(convert(V,rowvec.vec)) - -# similar tries to maintain the RowVector wrapper and the parent type -@inline similar(rowvec::RowVector) = RowVector(similar(parent(rowvec))) -@inline similar(rowvec::RowVector, ::Type{T}) where {T} = RowVector(similar(parent(rowvec), transpose_type(T))) - -# Resizing similar currently loses its RowVector property. -@inline similar(rowvec::RowVector, ::Type{T}, dims::Dims{N}) where {T,N} = similar(parent(rowvec), T, dims) - -# Basic methods - -# replaced in the Adjoint/Transpose transition -# """ -# transpose(v::AbstractVector) -# -# The transposition operator (`.'`). -# -# # Examples -# ```jldoctest -# julia> v = [1,2,3] -# 3-element Array{Int64,1}: -# 1 -# 2 -# 3 -# -# julia> transpose(v) -# 1×3 RowVector{Int64,Array{Int64,1}}: -# 1 2 3 -# ``` -# """ -# @inline transpose(vec::AbstractVector) = RowVector(vec) -# @inline adjoint(vec::AbstractVector) = RowVector(_conj(vec)) - -# methods necessary to preserve RowVector's behavior through the Adjoint/Transpose transition -rvadjoint(v::AbstractVector) = RowVector(_conj(v)) -rvtranspose(v::AbstractVector) = RowVector(v) -rvadjoint(v::RowVector) = conj(v.vec) -rvadjoint(v::RowVector{<:Real}) = v.vec -rvtranspose(v::RowVector) = v.vec -rvtranspose(v::ConjRowVector) = copy(v.vec) -rvadjoint(x) = adjoint(x) -rvtranspose(x) = transpose(x) - -@inline transpose(rowvec::RowVector) = rowvec.vec -@inline transpose(rowvec::ConjRowVector) = copy(rowvec.vec) # remove the ConjArray wrapper from any raw vector -@inline adjoint(rowvec::RowVector) = conj(rowvec.vec) -@inline adjoint(rowvec::RowVector{<:Real}) = rowvec.vec - -parent(rowvec::RowVector) = rowvec.vec -vec(rowvec::RowVector) = rowvec.vec - -""" - conj(v::RowVector) - -Return a [`ConjArray`](@ref) lazy view of the input, where each element is conjugated. - -# Examples -```jldoctest -julia> v = RowVector([1+im, 1-im]) -1×2 RowVector{Complex{Int64},Array{Complex{Int64},1}}: - 1+1im 1-1im - -julia> conj(v) -1×2 RowVector{Complex{Int64},ConjArray{Complex{Int64},1,Array{Complex{Int64},1}}}: - 1-1im 1+1im -``` -""" -@inline conj(rowvec::RowVector) = RowVector(_conj(rowvec.vec)) -@inline conj(rowvec::RowVector{<:Real}) = rowvec - -# AbstractArray interface -@inline length(rowvec::RowVector) = length(rowvec.vec) -@inline size(rowvec::RowVector) = (1, length(rowvec.vec)) -@inline size(rowvec::RowVector, d) = ifelse(d==2, length(rowvec.vec), 1) -@inline axes(rowvec::RowVector) = (Base.OneTo(1), axes(rowvec.vec)[1]) -@inline axes(rowvec::RowVector, d) = ifelse(d == 2, axes(rowvec.vec)[1], Base.OneTo(1)) -IndexStyle(::RowVector) = IndexLinear() -IndexStyle(::Type{<:RowVector}) = IndexLinear() - -@propagate_inbounds getindex(rowvec::RowVector, i::Int) = rvtranspose(rowvec.vec[i]) -@propagate_inbounds setindex!(rowvec::RowVector, v, i::Int) = (setindex!(rowvec.vec, rvtranspose(v), i); rowvec) - -# Keep a RowVector where appropriate -@propagate_inbounds getindex(rowvec::RowVector, ::Colon, i::Int) = rvtranspose.(rowvec.vec[i:i]) -@propagate_inbounds getindex(rowvec::RowVector, ::Colon, inds::AbstractArray{Int}) = RowVector(rowvec.vec[inds]) -@propagate_inbounds getindex(rowvec::RowVector, ::Colon, ::Colon) = RowVector(rowvec.vec[:]) - -# helper function for below -@inline to_vec(rowvec::RowVector) = map(rvtranspose, rvtranspose(rowvec)) -@inline to_vec(x::Number) = x -@inline to_vecs(rowvecs...) = (map(to_vec, rowvecs)...,) - -# map: Preserve the RowVector by un-wrapping and re-wrapping, but note that `f` -# expects to operate within the transposed domain, so to_vec transposes the elements -@inline map(f, rowvecs::RowVector...) = RowVector(map(rvtranspose∘f, to_vecs(rowvecs...)...)) - -# broacast (other combinations default to higher-dimensional array) -@inline broadcast(f, rowvecs::Union{Number,RowVector}...) = - RowVector(broadcast(transpose∘f, to_vecs(rowvecs...)...)) - -# Horizontal concatenation # - -@inline hcat(X::RowVector...) = rvtranspose(vcat(map(rvtranspose, X)...)) -@inline hcat(X::Union{RowVector,Number}...) = rvtranspose(vcat(map(rvtranspose, X)...)) - -@inline typed_hcat(::Type{T}, X::RowVector...) where {T} = - rvtranspose(typed_vcat(T, map(rvtranspose, X)...)) -@inline typed_hcat(::Type{T}, X::Union{RowVector,Number}...) where {T} = - rvtranspose(typed_vcat(T, map(rvtranspose, X)...)) - -# Multiplication # - -# inner product -> dot product specializations -@inline *(rowvec::RowVector{T}, vec::AbstractVector{T}) where {T<:Real} = dot(parent(rowvec), vec) -@inline *(rowvec::ConjRowVector{T}, vec::AbstractVector{T}) where {T<:Real} = dot(rvadjoint(rowvec), vec) -@inline *(rowvec::ConjRowVector, vec::AbstractVector) = dot(rvadjoint(rowvec), vec) - -# Generic behavior -@inline function *(rowvec::RowVector, vec::AbstractVector) - if length(rowvec) != length(vec) - throw(DimensionMismatch("A has dimensions $(size(rowvec)) but B has dimensions $(size(vec))")) - end - sum(@inbounds(return rowvec[i]*vec[i]) for i = 1:length(vec)) -end -@inline *(rowvec::RowVector, mat::AbstractMatrix) = rvtranspose(Transpose(mat) * rvtranspose(rowvec)) -*(::RowVector, ::RowVector) = throw(DimensionMismatch("Cannot multiply two transposed vectors")) -@inline *(vec::AbstractVector, rowvec::RowVector) = vec .* rowvec -*(vec::AbstractVector, rowvec::AbstractVector) = throw(DimensionMismatch("Cannot multiply two vectors")) - -# Transposed forms -*(::RowVector, ::Transpose{<:Any,<:AbstractVector}) = - throw(DimensionMismatch("Cannot multiply two transposed vectors")) -*(rowvec::RowVector, transmat::Transpose{<:Any,<:AbstractMatrix}) = - (mat = transmat.parent; rvtranspose(mat * rvtranspose(rowvec))) -*(rowvec1::RowVector, transrowvec2::Transpose{<:Any,<:RowVector}) = - (rowvec2 = transrowvec2.parent; rowvec1*rvtranspose(rowvec2)) -*(::AbstractVector, ::Transpose{<:Any,<:RowVector}) = - throw(DimensionMismatch("Cannot multiply two vectors")) -*(mat::AbstractMatrix, transrowvec::Transpose{<:Any,<:RowVector}) = - (rowvec = transrowvec.parent; mat * rvtranspose(rowvec)) - -*(transrowvec::Transpose{<:Any,<:RowVector}, transvec::Transpose{<:Any,<:AbstractVector}) = - rvtranspose(transrowvec.parent) * transpose(transvec.parent) -*(transrowvec1::Transpose{<:Any,<:RowVector}, transrowvec2::Transpose{<:Any,<:RowVector}) = - throw(DimensionMismatch("Cannot multiply two vectors")) -*(transvec::Transpose{<:Any,<:AbstractVector}, transrowvec::Transpose{<:Any,<:RowVector}) = - transpose(transvec.parent)*rvtranspose(transrowvec.parent) -*(transmat::Transpose{<:Any,<:AbstractMatrix}, transrowvec::Transpose{<:Any,<:RowVector}) = - transmat * rvtranspose(transrowvec.parent) - -*(::Transpose{<:Any,<:RowVector}, ::AbstractVector) = - throw(DimensionMismatch("Cannot multiply two vectors")) -*(transrowvec1::Transpose{<:Any,<:RowVector}, rowvec2::RowVector) = - rvtranspose(transrowvec1.parent) * rowvec2 -*(transvec::Transpose{<:Any,<:AbstractVector}, rowvec::RowVector) = - throw(DimensionMismatch("Cannot multiply two transposed vectors")) - -# Conjugated forms -*(::RowVector, ::Adjoint{<:Any,<:AbstractVector}) = - throw(DimensionMismatch("Cannot multiply two transposed vectors")) -*(rowvec::RowVector, adjmat::Adjoint{<:Any,<:AbstractMatrix}) = - rvadjoint(adjmat.parent * rvadjoint(rowvec)) -*(rowvec1::RowVector, adjrowvec2::Adjoint{<:Any,<:RowVector}) = - rowvec1 * rvadjoint(adjrowvec2.parent) -*(vec::AbstractVector, adjrowvec::Adjoint{<:Any,<:RowVector}) = - throw(DimensionMismatch("Cannot multiply two vectors")) -*(mat::AbstractMatrix, adjrowvec::Adjoint{<:Any,<:RowVector}) = - mat * rvadjoint(adjrowvec.parent) - -*(adjrowvec::Adjoint{<:Any,<:RowVector}, adjvec::Adjoint{<:Any,<:AbstractVector}) = - rvadjoint(adjrowvec.parent) * adjoint(adjvec.parent) -*(adjrowvec1::Adjoint{<:Any,<:RowVector}, adjrowvec2::Adjoint{<:Any,<:RowVector}) = - throw(DimensionMismatch("Cannot multiply two vectors")) -*(adjvec::Adjoint{<:Any,<:AbstractVector}, adjrowvec::Adjoint{<:Any,<:RowVector}) = - adjoint(adjvec.parent)*rvadjoint(adjrowvec.parent) -*(adjmat::Adjoint{<:Any,<:AbstractMatrix}, adjrowvec::Adjoint{<:Any,<:RowVector}) = - adjoint(adjmat.parent) * rvadjoint(adjrowvec.parent) - -*(::Adjoint{<:Any,<:RowVector}, ::AbstractVector) = throw(DimensionMismatch("Cannot multiply two vectors")) -*(adjrowvec1::Adjoint{<:Any,<:RowVector}, rowvec2::RowVector) = rvadjoint(adjrowvec1.parent) * rowvec2 -*(adjvec::Adjoint{<:Any,<:AbstractVector}, rowvec::RowVector) = throw(DimensionMismatch("Cannot multiply two transposed vectors")) - -# Pseudo-inverse -pinv(v::RowVector, tol::Real=0) = rvadjoint(pinv(rvadjoint(v), tol)) - -# Left Division # - -\(rowvec1::RowVector, rowvec2::RowVector) = pinv(rowvec1) * rowvec2 -\(mat::AbstractMatrix, rowvec::RowVector) = throw(DimensionMismatch("Cannot left-divide transposed vector by matrix")) -\(transmat::Transpose{<:Any,<:AbstractMatrix}, rowvec::RowVector) = - throw(DimensionMismatch("Cannot left-divide transposed vector by matrix")) -\(adjmat::Adjoint{<:Any,<:AbstractMatrix}, rowvec::RowVector) = - throw(DimensionMismatch("Cannot left-divide transposed vector by matrix")) - -# Right Division # - -@inline /(rowvec::RowVector, mat::AbstractMatrix) = rvtranspose(transpose(mat) \ rvtranspose(rowvec)) -/(rowvec::RowVector, transmat::Transpose{<:Any,<:AbstractMatrix}) = rvtranspose(transmat.parent \ rvtranspose(rowvec)) -/(rowvec::RowVector, adjmat::Adjoint{<:Any,<:AbstractMatrix}) = rvadjoint(adjmat.parent \ rvadjoint(rowvec)) - - -# definitions necessary for test/linalg/dense.jl to pass -# should be cleaned up / revised as necessary in the future -/(A::Number, B::Adjoint{<:Any,<:RowVector}) = /(A, rvadjoint(B.parent)) -/(A::Matrix, B::RowVector) = rvadjoint(rvadjoint(B) \ adjoint(A)) - - -# dismabiguation methods -*(A::Adjoint{<:Any,<:AbstractVector}, B::Transpose{<:Any,<:RowVector}) = adjoint(A.parent) * B -*(A::Adjoint{<:Any,<:AbstractMatrix}, B::Transpose{<:Any,<:RowVector}) = A * rvtranspose(B.parent) -*(A::Transpose{<:Any,<:AbstractVector}, B::Adjoint{<:Any,<:RowVector}) = transpose(A.parent) * B -*(A::Transpose{<:Any,<:AbstractMatrix}, B::Adjoint{<:Any,<:RowVector}) = A * rvadjoint(B.parent) diff --git a/base/sparse/sparsevector.jl b/base/sparse/sparsevector.jl index 3941849f5be90..4ee09d93a8080 100644 --- a/base/sparse/sparsevector.jl +++ b/base/sparse/sparsevector.jl @@ -986,7 +986,7 @@ vcat(X::Union{Vector,SparseVector}...) = vcat(map(sparse, X)...) # TODO: A definition similar to the third exists in base/linalg/bidiag.jl. These definitions # should be consolidated in a more appropriate location, e.g. base/linalg/special.jl. -const _SparseArrays = Union{SparseVector, SparseMatrixCSC, RowVector{<:Any,<:SparseVector}, Adjoint{<:Any,<:SparseVector}, Transpose{<:Any,<:SparseVector}} +const _SparseArrays = Union{SparseVector, SparseMatrixCSC, Base.LinAlg.RowVector{<:Any,<:SparseVector}, Adjoint{<:Any,<:SparseVector}, Transpose{<:Any,<:SparseVector}} const _SpecialArrays = Union{Diagonal, Bidiagonal, Tridiagonal, SymTridiagonal} const _SparseConcatArrays = Union{_SpecialArrays, _SparseArrays} @@ -1001,9 +1001,9 @@ const _Triangular_DenseArrays{T,A<:Matrix} = Base.LinAlg.AbstractTriangular{T,A} const _Annotated_DenseArrays = Union{_Triangular_DenseArrays, _Symmetric_DenseArrays, _Hermitian_DenseArrays} const _Annotated_Typed_DenseArrays{T} = Union{_Triangular_DenseArrays{T}, _Symmetric_DenseArrays{T}, _Hermitian_DenseArrays{T}} -const _SparseConcatGroup = Union{Vector, Adjoint{<:Any,<:Vector}, Transpose{<:Any,<:Vector}, RowVector{<:Any,<:Vector}, Matrix, _SparseConcatArrays, _Annotated_SparseConcatArrays, _Annotated_DenseArrays} -const _DenseConcatGroup = Union{Vector, Adjoint{<:Any,<:Vector}, Transpose{<:Any,<:Vector}, RowVector{<:Any, <:Vector}, Matrix, _Annotated_DenseArrays} -const _TypedDenseConcatGroup{T} = Union{Vector{T}, Adjoint{T,Vector{T}}, Transpose{T,Vector{T}}, RowVector{T,Vector{T}}, Matrix{T}, _Annotated_Typed_DenseArrays{T}} +const _SparseConcatGroup = Union{Vector, Adjoint{<:Any,<:Vector}, Transpose{<:Any,<:Vector}, Base.LinAlg.RowVector{<:Any,<:Vector}, Matrix, _SparseConcatArrays, _Annotated_SparseConcatArrays, _Annotated_DenseArrays} +const _DenseConcatGroup = Union{Vector, Adjoint{<:Any,<:Vector}, Transpose{<:Any,<:Vector}, Base.LinAlg.RowVector{<:Any, <:Vector}, Matrix, _Annotated_DenseArrays} +const _TypedDenseConcatGroup{T} = Union{Vector{T}, Adjoint{T,Vector{T}}, Transpose{T,Vector{T}}, Base.LinAlg.RowVector{T,Vector{T}}, Matrix{T}, _Annotated_Typed_DenseArrays{T}} # Concatenations involving un/annotated sparse/special matrices/vectors should yield sparse arrays function cat(catdims, Xin::_SparseConcatGroup...) diff --git a/test/choosetests.jl b/test/choosetests.jl index 2ca50d182bf88..5989e266bbde5 100644 --- a/test/choosetests.jl +++ b/test/choosetests.jl @@ -125,8 +125,7 @@ function choosetests(choices = []) "linalg/diagonal", "linalg/pinv", "linalg/givens", "linalg/cholesky", "linalg/lu", "linalg/symmetric", "linalg/generic", "linalg/uniformscaling", "linalg/lq", - "linalg/hessenberg", "linalg/rowvector", - "linalg/blas", "linalg/adjtrans"] + "linalg/hessenberg", "linalg/blas", "linalg/adjtrans"] if "linalg" in skip_tests filter!(x -> (x != "linalg" && !(x in linalgtests)), tests) diff --git a/test/linalg/cholesky.jl b/test/linalg/cholesky.jl index 9fa47ff994870..fb7dc8065ea5a 100644 --- a/test/linalg/cholesky.jl +++ b/test/linalg/cholesky.jl @@ -158,7 +158,6 @@ end @test norm(apd * (lapd\b) - b)/norm(b) <= ε*κ*n @test norm(apd * (lapd\b[1:n]) - b[1:n])/norm(b[1:n]) <= ε*κ*n end - @test_throws DimensionMismatch cholfact(apdhL)\RowVector(ones(n)) if eltya != BigFloat && eltyb != BigFloat # Note! Need to implement pivoted Cholesky decomposition in julia @@ -170,7 +169,6 @@ end @test norm(apd * (lpapd\b) - b)/norm(b) <= ε*κ*n # Ad hoc, revisit @test norm(apd * (lpapd\b[1:n]) - b[1:n])/norm(b[1:n]) <= ε*κ*n - @test_throws BoundsError lpapd\RowVector(ones(n)) end end end diff --git a/test/linalg/rowvector.jl b/test/linalg/rowvector.jl deleted file mode 100644 index 67bc09cb8eb8e..0000000000000 --- a/test/linalg/rowvector.jl +++ /dev/null @@ -1,318 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -using Base.LinAlg: Adjoint, Transpose - -# these definitions are what adjoint(...) and transpose(...) meant -# meant prior to the Adjoint/Transpose transition, and the tests -# below are re-expressed in them to shield them against changes -# to adjoint(...), transpose(...), .', ', and A[ct]_(mul|ldiv|rdiv)_B[ct] -using Base.LinAlg: _conj, ConjRowVector -rvadjoint(v::AbstractVector) = RowVector(_conj(v)) -rvtranspose(v::AbstractVector) = RowVector(v) -rvadjoint(v::RowVector) = conj(v.vec) -rvadjoint(v::RowVector{<:Real}) = v.vec -rvtranspose(v::RowVector) = v.vec -rvtranspose(v::ConjRowVector) = copy(v.vec) - -@testset "Core" begin - v = [1,2,3] - z = [1+im,2,3] - - @test RowVector(v) == [1 2 3] - @test RowVector{Int}(v) == [1 2 3] - @test size(RowVector{Int}(uninitialized, 3)) === (1,3) - @test size(RowVector{Int}(uninitialized, 1,3)) === (1,3) - @test size(RowVector{Int}(uninitialized, (3,))) === (1,3) - @test size(RowVector{Int}(uninitialized, (1,3))) === (1,3) - @test_throws ErrorException RowVector{Float64, Vector{Int}}(v) - - @test rvtranspose(v)::RowVector == [1 2 3] - @test rvadjoint(v)::RowVector == [1 2 3] - @test rvtranspose(z)::RowVector == [1+im 2 3] - @test rvadjoint(z)::RowVector == [1-im 2 3] - - rv = rvtranspose(v) - tz = rvtranspose(z) - - @test rvtranspose(rv)::Vector == [1, 2, 3] - @test rvadjoint(rv)::Vector == [1, 2, 3] - @test rvtranspose(tz)::Vector == [1+im, 2, 3] - @test rvadjoint(tz)::Vector == [1-im, 2, 3] - - @test conj(rv) === rv - @test conj(tz) == [1-im 2 3] - - @test isa(similar(rv), RowVector) - @test isa(similar(rv, Float64), RowVector) - @test isa(copy(rv), RowVector) - - @test rv[2] === v[2] - @test rv[1,2] === v[2] - - @test (rv2 = copy(rv); rv2[2] = 6; rv2[2] === 6) - @test (rv2 = copy(rv); rv2[1,2] = 6; rv2[2] === 6) - - @test length(rv) === 3 - @test size(rv) === (1,3) - @test size(rv,1) === 1 - @test size(rv,2) === 3 - - @test map(-, rv)::RowVector == [-1 -2 -3] - @test (-).(rv)::RowVector == [-1 -2 -3] - @test (-).(rv,1)::RowVector == [0 1 2] - - y = rand(Complex{Float64},3) - @test sum(abs2, imag.(diag(y .+ rvadjoint(y)))) < 1e-20 - - @test parent(rv) === v - @test vec(rv) === v -end - -@testset "Diagonal ambiguity methods" begin - d = Diagonal([1,2,3]) - v = [2,3,4] - rv = rvtranspose(v) - - @test (rv*d)::RowVector == rvtranspose([2,6,12]) - @test_throws DimensionMismatch d*rv - - @test (d*rvtranspose(rv))::Vector == [2,6,12] - - @test_throws DimensionMismatch rvtranspose(rv)*d - - @test (d*rvadjoint(rv))::Vector == [2,6,12] - - @test_throws DimensionMismatch rvadjoint(rv)*d - - @test (rv/d)::RowVector ≈ [2/1 3/2 4/3] - - @test_throws DimensionMismatch d \ rv -end - -@testset "Bidiagonal ambiguity methods" begin - bd = Bidiagonal([1,2,3], [0,0], :U) - v = [2,3,4] - rv = rvtranspose(v) - - @test (rv/bd)::RowVector ≈ [2/1 3/2 4/3] - - @test_throws DimensionMismatch bd \ rv -end - -@testset "hcat" begin - @test isa([rvtranspose([1, 2, 3]) 4], RowVector{Int}) - @test isa([rvtranspose([1, 2, 3]) rvtranspose([4, 5])], RowVector{Int}) -end - -@testset "Left Division" begin - mat = Matrix(Diagonal([1,2,3])) - v = [2,3,4] - rv = rvtranspose(v) - - @test_throws DimensionMismatch mat \ rv -end - -@testset "Multiplication" begin - v = [1,2,3] - rv = rvtranspose(v) - mat = Matrix(Diagonal([1,2,3])) - - @test (rv*v) === 14 - @test (rv*mat)::RowVector == [1 4 9] - @test [1]*reshape([1],(1,1)) == reshape([1], (1,1)) - @test_throws DimensionMismatch rv*rv - @test (v*rv)::Matrix == [1 2 3; 2 4 6; 3 6 9] - @test_throws DimensionMismatch v*v # Was previously a missing method error, now an error message - @test_throws DimensionMismatch mat*rv - - @test_throws DimensionMismatch rv*rvtranspose(v) - @test (rv*Transpose(mat))::RowVector == [1 4 9] - @test [1]*Transpose(reshape([1],(1,1))) == reshape([1], (1,1)) - @test rv*rvtranspose(rv) === 14 - @test_throws DimensionMismatch v*rvtranspose(rv) - @test (v*rvtranspose(v))::Matrix == [1 2 3; 2 4 6; 3 6 9] - @test (mat*rvtranspose(rv))::Vector == [1,4,9] - - @test (rvtranspose(rv)*rvtranspose(v))::Matrix == [1 2 3; 2 4 6; 3 6 9] - @test_throws DimensionMismatch rvtranspose(rv)*Transpose(mat) - @test (rvtranspose(v)*Transpose(mat))::RowVector == [1 4 9] - @test_throws DimensionMismatch rvtranspose(rv)*rvtranspose(rv) - @test rvtranspose(v)*rvtranspose(rv) === 14 - @test_throws DimensionMismatch rvtranspose(v)*rvtranspose(v) - @test (Transpose(mat)*rvtranspose(rv))::Vector == [1,4,9] - - @test_throws DimensionMismatch rvtranspose(rv)*v - @test_throws DimensionMismatch rvtranspose(rv)*mat - @test (rvtranspose(v)*mat)::RowVector == [1 4 9] - @test (rvtranspose(rv)*rv)::Matrix == [1 2 3; 2 4 6; 3 6 9] - @test_throws DimensionMismatch rvtranspose(v)*rv - @test rvtranspose(v)*v === 14 - @test_throws DimensionMismatch Transpose(mat)*rv - - z = [1+im,2,3] - cz = rvadjoint(z) - mat = Matrix(Diagonal([1+im,2,3])) - - @test cz*z === 15 + 0im - - @test_throws DimensionMismatch cz*rvadjoint(z) - @test (cz*Adjoint(mat))::RowVector == [-2im 4 9] - @test [1]*Adjoint(reshape([1],(1,1))) == reshape([1], (1,1)) - @test cz*rvadjoint(cz) === 15 + 0im - @test_throws DimensionMismatch z*rvadjoint(cz) - @test (z*rvadjoint(z))::Matrix == [2 2+2im 3+3im; 2-2im 4 6; 3-3im 6 9] - @test (mat*rvadjoint(cz))::Vector == [2im,4,9] - - @test (rvadjoint(cz)*rvadjoint(z))::Matrix == [2 2+2im 3+3im; 2-2im 4 6; 3-3im 6 9] - @test_throws DimensionMismatch rvadjoint(cz)*Adjoint(mat) - @test (rvadjoint(z)*Adjoint(mat))::RowVector == [-2im 4 9] - @test_throws DimensionMismatch rvadjoint(cz)*rvadjoint(cz) - @test rvadjoint(z)*rvadjoint(cz) === 15 + 0im - @test_throws DimensionMismatch rvadjoint(z)*rvadjoint(z) - @test (Adjoint(mat)*rvadjoint(cz))::Vector == [2,4,9] - - @test_throws DimensionMismatch rvadjoint(cz)*z - @test_throws DimensionMismatch rvadjoint(cz)*mat - @test (rvadjoint(z)*mat)::RowVector == [2 4 9] - @test (rvadjoint(cz)*cz)::Matrix == [2 2+2im 3+3im; 2-2im 4 6; 3-3im 6 9] - @test_throws DimensionMismatch rvadjoint(z)*cz - @test rvadjoint(z)*z === 15 + 0im - @test_throws DimensionMismatch Adjoint(mat)*cz -end - -@testset "norm" begin - @test norm(rvtranspose([3.0,4.0])) ≈ 5.0 - @test norm(rvtranspose([3.0,4.0]), 1) ≈ 4.0 - @test norm(rvtranspose([3.0,4.0]), Inf) ≈ 7.0 -end - -@testset "QR ambiguity methods" begin - qrmat = qrfact(Matrix(1.0I, 3, 3)).Q - v = [2,3,4] - rv = rvtranspose(v) - - @test (rv*Adjoint(qrmat))::RowVector == [2 3 4] -end - -@testset "Right Division" begin - mat = Matrix(Diagonal([1,2,3])) - v = [2,3,4] - rv = rvtranspose(v) - - @test (rv/mat)::RowVector ≈ [2/1 3/2 4/3] - - @test (rvtranspose(v)/mat)::RowVector ≈ [2/1 3/2 4/3] - @test (rvtranspose(v)/Transpose(mat))::RowVector ≈ [2/1 3/2 4/3] - @test (rv/Transpose(mat))::RowVector ≈ [2/1 3/2 4/3] - - @test (rvadjoint(v)/mat)::RowVector ≈ [2/1 3/2 4/3] - @test (rvadjoint(v)/Adjoint(mat))::RowVector ≈ [2/1 3/2 4/3] - @test (rv/Adjoint(mat))::RowVector ≈ [2/1 3/2 4/3] -end - -@testset "Sparse ambiguity methods" begin - mat = sparse(Diagonal([1,2,3])) - v = [2,3,4] - rv = rvtranspose(v) - - @test (rv/mat)::RowVector ≈ [2/1 3/2 4/3] - - @test_throws DimensionMismatch mat\rv -end - -@testset "AbstractTriangular ambiguity methods" begin - ut = UpperTriangular([1 0 0; 0 2 0; 0 0 3]) - v = [2,3,4] - rv = rvtranspose(v) - - @test (rv*ut)::RowVector == [2 6 12] - @test_throws DimensionMismatch ut*rv - - @test (rv*Transpose(ut))::RowVector == [2 6 12] - @test (ut*rvtranspose(rv))::Vector == [2,6,12] - - @test (Transpose(ut)*rvtranspose(rv))::Vector == [2,6,12] - @test_throws DimensionMismatch rvtranspose(rv)*Transpose(ut) - - @test_throws DimensionMismatch Transpose(ut)*rv - @test_throws DimensionMismatch rvtranspose(rv)*ut - - @test (rv*Adjoint(ut))::RowVector == [2 6 12] - @test (ut*rvadjoint(rv))::Vector == [2,6,12] - - @test_throws DimensionMismatch rvadjoint(rv)*Adjoint(ut) - @test (Adjoint(ut)*rvadjoint(rv))::Vector == [2,6,12] - - @test_throws DimensionMismatch Adjoint(ut)*rv - @test_throws DimensionMismatch rvadjoint(rv)*ut - - @test (rv/ut)::RowVector ≈ [2/1 3/2 4/3] - @test (rv/Transpose(ut))::RowVector ≈ [2/1 3/2 4/3] - @test (rv/Adjoint(ut))::RowVector ≈ [2/1 3/2 4/3] - - @test_throws DimensionMismatch ut\rv -end - -@testset "Symmetric/Hermitian ambiguity methods" begin - S = Symmetric(rand(3, 3)) - H = Hermitian(rand(3, 3)) - v = (rvadjoint(rand(3)))::RowVector - @test_throws DimensionMismatch S\v - @test_throws DimensionMismatch H\v -end - -# issue #20389 -@testset "1 row/col vec*mat" begin - let x=[1,2,3], A=ones(1,4), y=rvadjoint(x), B=adjoint(A), C=x.*A - @test x*A == rvadjoint(y)*A == x*Adjoint(B) == rvadjoint(y)*Adjoint(B) == C - @test Adjoint(A)*rvadjoint(x) == Adjoint(A)*y == B*rvadjoint(x) == B*y == adjoint(C) - end -end -@testset "complex 1 row/col vec*mat" begin - let x=[1,2,3]*im, A=ones(1,4)*im, y=rvadjoint(x), B=adjoint(A), C=x.*A - @test x*A == rvadjoint(y)*A == x*Adjoint(B) == rvadjoint(y)*Adjoint(B) == C - @test Adjoint(A)*rvadjoint(x) == Adjoint(A)*y == B*rvadjoint(x) == B*y == adjoint(C) - end -end - -@testset "issue #20979" begin - f20979(z::Complex) = [z.re -z.im; z.im z.re] - v = rvadjoint([1+2im]) - @test (f20979.(v))[1] == f20979(v[1]) - @test f20979.(v) == f20979.(collect(v)) - - w = rand(ComplexF64, 3) - @test f20979.(rvadjoint(v)) == f20979.(collect(rvadjoint(v))) == rvadjoint(f20979.(v)) - - g20979(x, y) = [x[2,1] x[1,2]; y[1,2] y[2,1]] - v = [rand(2,2), rand(2,2), rand(2,2)] - @test g20979.(rvadjoint(v), rvadjoint(v)) == g20979.(collect(rvadjoint(v)), collect(rvadjoint(v))) == - map(g20979, rvadjoint(v), rvadjoint(v)) == map(g20979, collect(rvadjoint(v)), collect(rvadjoint(v))) -end - -@testset "ambiguity between * methods with RowVectors and ConjRowVectors (#20971)" begin - @test RowVector(ConjArray(ones(4))) * ones(4) == 4 -end - -@testset "setindex!/getindex" begin - v = [2, 3, 4] - rv = rvtranspose(v) - @test_throws BoundsError setindex!(rv, 5, CartesianIndex((5, 4, 3))) - rv[CartesianIndex((1, 1, 1))] = 5 - @test_throws BoundsError getindex(rv, CartesianIndex((5, 4, 3))) - @test rv[1] == 5 - - @test rv[:, 2]::Vector == [v[2]] - @test rv[:, 2:3]::RowVector == rvtranspose(v[2:3]) - @test rv[:, :]::RowVector == rv - - v = [1] - rv = rvtranspose(v) - rv[CartesianIndex()] = 2 - @test rv[CartesianIndex()] == 2 - rv[CartesianIndex(1)] = 1 - @test rv[CartesianIndex(1)] == 1 - - # setindex!(v::RowVector, ...) should return v rather than v's parent - @test setindex!(RowVector([1, 2, 3]), 4, 1)::RowVector == [4 2 3] -end