diff --git a/NEWS.md b/NEWS.md index 9223278bead5d..5d34d215ba8d0 100644 --- a/NEWS.md +++ b/NEWS.md @@ -995,7 +995,7 @@ Deprecated or removed * `Base.@gc_preserve` has been deprecated in favor of `GC.@preserve` ([#25616]). - * `scale!` has been deprecated in favor of `mul!`, `mul1!`, and `mul2!` ([#25701]). + * `scale!` has been deprecated in favor of `mul!`, `lmul!`, and `rmul!` ([#25701], [#25812]). * `endof(a)` has been renamed to `lastindex(a)`, and the `end` keyword in indexing expressions now lowers to either `lastindex(a)` (in the case with only one index) or `lastindex(a, d)` (in cases diff --git a/stdlib/IterativeEigensolvers/src/IterativeEigensolvers.jl b/stdlib/IterativeEigensolvers/src/IterativeEigensolvers.jl index 83efd53258309..3bad088d82d54 100644 --- a/stdlib/IterativeEigensolvers/src/IterativeEigensolvers.jl +++ b/stdlib/IterativeEigensolvers/src/IterativeEigensolvers.jl @@ -9,7 +9,7 @@ module IterativeEigensolvers using LinearAlgebra: BlasFloat, BlasInt, Diagonal, I, SVD, UniformScaling, checksquare, factorize,ishermitian, issymmetric, mul!, - mul1!, qr + rmul!, qr import LinearAlgebra export eigs, svds @@ -317,10 +317,10 @@ function _svds(X; nsv::Int = 6, ritzvec::Bool = true, tol::Float64 = 0.0, maxite # left_sv = sqrt(2) * ex[2][ 1:size(X,1), ind ] .* sign.(ex[1][ind]') if size(X, 1) >= size(X, 2) V = ex[2] - U = qr(mul1!(X*V, Diagonal(inv.(svals))))[1] + U = qr(rmul!(X*V, Diagonal(inv.(svals))))[1] else U = ex[2] - V = qr(mul1!(X'U, Diagonal(inv.(svals))))[1] + V = qr(rmul!(X'U, Diagonal(inv.(svals))))[1] end # right_sv = sqrt(2) * ex[2][ size(X,1)+1:end, ind ] diff --git a/stdlib/LinearAlgebra/docs/src/index.md b/stdlib/LinearAlgebra/docs/src/index.md index e48cf840c051b..00d677f2f4556 100644 --- a/stdlib/LinearAlgebra/docs/src/index.md +++ b/stdlib/LinearAlgebra/docs/src/index.md @@ -427,8 +427,8 @@ below (e.g. `mul!`) according to the usual Julia convention. ```@docs LinearAlgebra.mul! -LinearAlgebra.mul1! -LinearAlgebra.mul2! +LinearAlgebra.lmul! +LinearAlgebra.rmul! LinearAlgebra.ldiv! LinearAlgebra.rdiv! ``` diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl index 7bc0b490d72fe..a28437128b4b8 100644 --- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl +++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl @@ -115,8 +115,8 @@ export lufact!, lyap, mul!, - mul1!, - mul2!, + lmul!, + rmul!, norm, normalize, normalize!, diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl index d838e347fadf2..1abf8a4e6ce14 100644 --- a/stdlib/LinearAlgebra/src/dense.jl +++ b/stdlib/LinearAlgebra/src/dense.jl @@ -14,21 +14,21 @@ const NRM2_CUTOFF = 32 # This constant should ideally be determined by the actual CPU cache size const ISONE_CUTOFF = 2^21 # 2M -function mul1!(X::Array{T}, s::T) where T<:BlasFloat +function rmul!(X::Array{T}, s::T) where T<:BlasFloat s == 0 && return fill!(X, zero(T)) s == 1 && return X if length(X) < SCAL_CUTOFF - generic_mul1!(X, s) + generic_rmul!(X, s) else BLAS.scal!(length(X), s, X, 1) end X end -mul2!(s::T, X::Array{T}) where {T<:BlasFloat} = mul1!(X, s) +lmul!(s::T, X::Array{T}) where {T<:BlasFloat} = rmul!(X, s) -mul1!(X::Array{T}, s::Number) where {T<:BlasFloat} = mul1!(X, convert(T, s)) -function mul1!(X::Array{T}, s::Real) where T<:BlasComplex +rmul!(X::Array{T}, s::Number) where {T<:BlasFloat} = rmul!(X, convert(T, s)) +function rmul!(X::Array{T}, s::Real) where T<:BlasComplex R = typeof(real(zero(T))) GC.@preserve X BLAS.scal!(2*length(X), convert(R,s), convert(Ptr{R},pointer(X)), 1) X @@ -1402,7 +1402,7 @@ function sylvester(A::StridedMatrix{T},B::StridedMatrix{T},C::StridedMatrix{T}) D = -(adjoint(QA) * (C*QB)) Y, scale = LAPACK.trsyl!('N','N', RA, RB, D) - mul1!(QA*(Y * adjoint(QB)), inv(scale)) + rmul!(QA*(Y * adjoint(QB)), inv(scale)) end sylvester(A::StridedMatrix{T}, B::StridedMatrix{T}, C::StridedMatrix{T}) where {T<:Integer} = sylvester(float(A), float(B), float(C)) @@ -1445,7 +1445,7 @@ function lyap(A::StridedMatrix{T}, C::StridedMatrix{T}) where {T<:BlasFloat} D = -(adjoint(Q) * (C*Q)) Y, scale = LAPACK.trsyl!('N', T <: Complex ? 'C' : 'T', R, R, D) - mul1!(Q*(Y * adjoint(Q)), inv(scale)) + rmul!(Q*(Y * adjoint(Q)), inv(scale)) end lyap(A::StridedMatrix{T}, C::StridedMatrix{T}) where {T<:Integer} = lyap(float(A), float(C)) lyap(a::T, c::T) where {T<:Number} = -c/(2a) diff --git a/stdlib/LinearAlgebra/src/deprecated.jl b/stdlib/LinearAlgebra/src/deprecated.jl index b19fe1b917785..d1b94d363eff2 100644 --- a/stdlib/LinearAlgebra/src/deprecated.jl +++ b/stdlib/LinearAlgebra/src/deprecated.jl @@ -711,11 +711,11 @@ export A_ldiv_B!, @deprecate A_mul_B!(C::StridedVecOrMat, S::SymTridiagonal, B::StridedVecOrMat) mul!(C, S, B) # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/diagonal.jl, to deprecate -@deprecate A_mul_B!(A::Union{LowerTriangular,UpperTriangular}, D::Diagonal) mul1!(A, D) -@deprecate A_mul_B!(A::UnitLowerTriangular, D::Diagonal) mul1!(A, D) -@deprecate A_mul_B!(A::UnitUpperTriangular, D::Diagonal) mul1!(A, D) -@deprecate A_mul_B!(D::Diagonal, B::UnitLowerTriangular) mul2!(D, B) -@deprecate A_mul_B!(D::Diagonal, B::UnitUpperTriangular) mul2!(D, B) +@deprecate A_mul_B!(A::Union{LowerTriangular,UpperTriangular}, D::Diagonal) rmul!(A, D) +@deprecate A_mul_B!(A::UnitLowerTriangular, D::Diagonal) rmul!(A, D) +@deprecate A_mul_B!(A::UnitUpperTriangular, D::Diagonal) rmul!(A, D) +@deprecate A_mul_B!(D::Diagonal, B::UnitLowerTriangular) lmul!(D, B) +@deprecate A_mul_B!(D::Diagonal, B::UnitUpperTriangular) lmul!(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) @@ -732,18 +732,18 @@ export A_ldiv_B!, @deprecate Ac_mul_Bc(D::Diagonal, B::Diagonal) (*)(adjoint(D), adjoint(B)) @deprecate At_mul_Bt(D::Diagonal, B::Diagonal) (*)(transpose(D), transpose(B)) function A_mul_B!(A::Diagonal,B::Diagonal) - depwarn("`A_mul_B!(A::Diagonal,B::Diagonal)` should be replaced with `mul1!(A, B)` or `mul2!(A, B)`.", :A_mul_B!) + depwarn("`A_mul_B!(A::Diagonal,B::Diagonal)` should be replaced with `rmul!(A, B)` or `lmul!(A, B)`.", :A_mul_B!) throw(MethodError(A_mul_B!, (A, B))) end -@deprecate At_mul_B!(A::Diagonal,B::Diagonal) mul2!(transpose(A), B) -@deprecate Ac_mul_B!(A::Diagonal,B::Diagonal) mul2!(adjoint(A), B) -@deprecate A_mul_B!(A::QRPackedQ, D::Diagonal) mul1!(A, D) -@deprecate A_mul_B!(A::Diagonal,B::AbstractMatrix) mul2!(A, B) -@deprecate At_mul_B!(A::Diagonal,B::AbstractMatrix) mul2!(transpose(A), B) -@deprecate Ac_mul_B!(A::Diagonal,B::AbstractMatrix) mul2!(adjoint(A), B) -@deprecate A_mul_B!(A::AbstractMatrix,B::Diagonal) mul1!(A, B) -@deprecate A_mul_Bt!(A::AbstractMatrix,B::Diagonal) mul1!(A, transpose(B)) -@deprecate A_mul_Bc!(A::AbstractMatrix,B::Diagonal) mul1!(A, adjoint(B)) +@deprecate At_mul_B!(A::Diagonal,B::Diagonal) lmul!(transpose(A), B) +@deprecate Ac_mul_B!(A::Diagonal,B::Diagonal) lmul!(adjoint(A), B) +@deprecate A_mul_B!(A::QRPackedQ, D::Diagonal) rmul!(A, D) +@deprecate A_mul_B!(A::Diagonal,B::AbstractMatrix) lmul!(A, B) +@deprecate At_mul_B!(A::Diagonal,B::AbstractMatrix) lmul!(transpose(A), B) +@deprecate Ac_mul_B!(A::Diagonal,B::AbstractMatrix) lmul!(adjoint(A), B) +@deprecate A_mul_B!(A::AbstractMatrix,B::Diagonal) rmul!(A, B) +@deprecate A_mul_Bt!(A::AbstractMatrix,B::Diagonal) rmul!(A, transpose(B)) +@deprecate A_mul_Bc!(A::AbstractMatrix,B::Diagonal) rmul!(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) @@ -767,7 +767,7 @@ end @deprecate A_ldiv_B!(D::Diagonal, B::StridedVecOrMat) ldiv!(D, B) # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/special.jl, to deprecate -@deprecate A_mul_Bc!(A::AbstractTriangular, B::Union{QRCompactWYQ,QRPackedQ}) mul1!(A, adjoint(B)) +@deprecate A_mul_Bc!(A::AbstractTriangular, B::Union{QRCompactWYQ,QRPackedQ}) rmul!(A, adjoint(B)) @deprecate A_mul_Bc(A::AbstractTriangular, B::Union{QRCompactWYQ,QRPackedQ}) (*)(A, adjoint(B)) # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/bunchkaufman.jl, to deprecate @@ -792,10 +792,10 @@ end @deprecate At_ldiv_B(F::Factorization, B) (\)(transpose(F), B) # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/hessenberg.jl, to deprecate -@deprecate A_mul_B!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} mul2!(Q, X) -@deprecate A_mul_B!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} mul1!(X, Q) -@deprecate Ac_mul_B!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} mul2!(adjoint(Q), X) -@deprecate A_mul_Bc!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} mul1!(X, adjoint(Q)) +@deprecate A_mul_B!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} lmul!(Q, X) +@deprecate A_mul_B!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} rmul!(X, Q) +@deprecate Ac_mul_B!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} lmul!(adjoint(Q), X) +@deprecate A_mul_Bc!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} rmul!(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)) @@ -845,43 +845,43 @@ end @deprecate Ac_ldiv_B!(A::LU{T,Tridiagonal{T,V}}, B::AbstractVecOrMat) where {T,V} ldiv!(adjoint(A), B) # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/lq.jl, to deprecate -@deprecate A_mul_B!(A::LQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} mul2!(A, B) +@deprecate A_mul_B!(A::LQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} lmul!(A, B) @deprecate A_mul_B!(A::LQ{T}, B::QR{T}) where {T<:BlasFloat} A*B @deprecate A_mul_B!(A::QR{T}, B::LQ{T}) where {T<:BlasFloat} A*B -@deprecate A_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} mul2!(A, B) -@deprecate Ac_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasReal} mul2!(adjoint(A), B) -@deprecate Ac_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} mul2!(adjoint(A), B) +@deprecate A_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} lmul!(A, B) +@deprecate Ac_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasReal} lmul!(adjoint(A), B) +@deprecate Ac_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} lmul!(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} mul1!(A, B) -@deprecate A_mul_Bc!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasReal} mul1!(A, adjoint(B)) -@deprecate A_mul_Bc!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasComplex} mul1!(A, adjoint(B)) +@deprecate A_mul_B!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasFloat} rmul!(A, B) +@deprecate A_mul_Bc!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasReal} rmul!(A, adjoint(B)) +@deprecate A_mul_Bc!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasComplex} rmul!(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) # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/qr.jl, to deprecate -@deprecate A_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} mul2!(A, B) -@deprecate A_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} mul2!(A, B) -@deprecate A_mul_B!(A::QRPackedQ, B::AbstractVecOrMat) mul2!(A, B) -@deprecate Ac_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} mul2!(adjoint(A), B) -@deprecate Ac_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} mul2!(adjoint(A), B) -@deprecate Ac_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} mul2!(adjoint(A), B) -@deprecate Ac_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} mul2!(adjoint(A), B) -@deprecate Ac_mul_B!(A::QRPackedQ, B::AbstractVecOrMat) mul2!(adjoint(A), B) +@deprecate A_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} lmul!(A, B) +@deprecate A_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} lmul!(A, B) +@deprecate A_mul_B!(A::QRPackedQ, B::AbstractVecOrMat) lmul!(A, B) +@deprecate Ac_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} lmul!(adjoint(A), B) +@deprecate Ac_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} lmul!(adjoint(A), B) +@deprecate Ac_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} lmul!(adjoint(A), B) +@deprecate Ac_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} lmul!(adjoint(A), B) +@deprecate Ac_mul_B!(A::QRPackedQ, B::AbstractVecOrMat) lmul!(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} mul1!(A, B) -@deprecate A_mul_B!(A::StridedVecOrMat{T}, B::QRPackedQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} mul1!(A, B) -@deprecate A_mul_B!(A::StridedMatrix,Q::QRPackedQ) mul1!(A, Q) -@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) where {T<:BlasReal} mul1!(A, adjoint(B)) -@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) where {T<:BlasComplex} mul1!(A, adjoint(B)) -@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRPackedQ{T}) where {T<:BlasReal} mul1!(A, adjoint(B)) -@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRPackedQ{T}) where {T<:BlasComplex} mul1!(A, adjoint(B)) -@deprecate A_mul_Bc!(A::StridedMatrix,Q::QRPackedQ) mul1!(A, adjoint(Q)) +@deprecate A_mul_B!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} rmul!(A, B) +@deprecate A_mul_B!(A::StridedVecOrMat{T}, B::QRPackedQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} rmul!(A, B) +@deprecate A_mul_B!(A::StridedMatrix,Q::QRPackedQ) rmul!(A, Q) +@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) where {T<:BlasReal} rmul!(A, adjoint(B)) +@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) where {T<:BlasComplex} rmul!(A, adjoint(B)) +@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRPackedQ{T}) where {T<:BlasReal} rmul!(A, adjoint(B)) +@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::QRPackedQ{T}) where {T<:BlasComplex} rmul!(A, adjoint(B)) +@deprecate A_mul_Bc!(A::StridedMatrix,Q::QRPackedQ) rmul!(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) @@ -974,20 +974,20 @@ end @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}) mul1!(A, adjoint(B)) -@deprecate A_mul_Bc!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) mul1!(A, adjoint(B)) -@deprecate A_mul_Bt!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) mul1!(A, transpose(B)) -@deprecate A_mul_Bt!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) mul1!(A, transpose(B)) +@deprecate A_mul_Bc!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) rmul!(A, adjoint(B)) +@deprecate A_mul_Bc!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) rmul!(A, adjoint(B)) +@deprecate A_mul_Bt!(A::UpperTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) rmul!(A, transpose(B)) +@deprecate A_mul_Bt!(A::LowerTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) rmul!(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) mul2!(adjoint(A), B) -@deprecate Ac_mul_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) mul2!(adjoint(A), B) -@deprecate At_mul_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) mul2!(transpose(A), B) -@deprecate At_mul_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) mul2!(transpose(A), B) +@deprecate Ac_mul_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) lmul!(adjoint(A), B) +@deprecate Ac_mul_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) lmul!(adjoint(A), B) +@deprecate At_mul_B!(A::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular) lmul!(transpose(A), B) +@deprecate At_mul_B!(A::Union{UpperTriangular,UnitUpperTriangular}, B::LowerTriangular) lmul!(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) @@ -1012,30 +1012,30 @@ end @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) mul1!(A, transpose(B)) -@deprecate A_mul_Bt!(A::StridedMatrix, B::LowerTriangular) mul1!(A, transpose(B)) -@deprecate A_mul_Bt!(A::StridedMatrix, B::UnitUpperTriangular) mul1!(A, transpose(B)) -@deprecate A_mul_Bt!(A::StridedMatrix, B::UpperTriangular) mul1!(A, transpose(B)) -@deprecate A_mul_Bc!(A::StridedMatrix, B::UnitLowerTriangular) mul1!(A, adjoint(B)) -@deprecate A_mul_Bc!(A::StridedMatrix, B::LowerTriangular) mul1!(A, adjoint(B)) -@deprecate A_mul_Bc!(A::StridedMatrix, B::UnitUpperTriangular) mul1!(A, adjoint(B)) -@deprecate A_mul_Bc!(A::StridedMatrix, B::UpperTriangular) mul1!(A, adjoint(B)) -@deprecate A_mul_B!(A::StridedMatrix, B::UnitLowerTriangular) mul1!(A, B) -@deprecate A_mul_B!(A::StridedMatrix, B::LowerTriangular) mul1!(A, B) -@deprecate A_mul_B!(A::StridedMatrix, B::UnitUpperTriangular) mul1!(A, B) -@deprecate A_mul_B!(A::StridedMatrix, B::UpperTriangular) mul1!(A, B) -@deprecate At_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) mul2!(transpose(A), B) -@deprecate At_mul_B!(A::LowerTriangular, B::StridedVecOrMat) mul2!(transpose(A), B) -@deprecate At_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) mul2!(transpose(A), B) -@deprecate At_mul_B!(A::UpperTriangular, B::StridedVecOrMat) mul2!(transpose(A), B) -@deprecate Ac_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) mul2!(adjoint(A), B) -@deprecate Ac_mul_B!(A::LowerTriangular, B::StridedVecOrMat) mul2!(adjoint(A), B) -@deprecate Ac_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) mul2!(adjoint(A), B) -@deprecate Ac_mul_B!(A::UpperTriangular, B::StridedVecOrMat) mul2!(adjoint(A), B) -@deprecate A_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) mul2!(A, B) -@deprecate A_mul_B!(A::LowerTriangular, B::StridedVecOrMat) mul2!(A, B) -@deprecate A_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) mul2!(A, B) -@deprecate A_mul_B!(A::UpperTriangular, B::StridedVecOrMat) mul2!(A, B) +@deprecate A_mul_Bt!(A::StridedMatrix, B::UnitLowerTriangular) rmul!(A, transpose(B)) +@deprecate A_mul_Bt!(A::StridedMatrix, B::LowerTriangular) rmul!(A, transpose(B)) +@deprecate A_mul_Bt!(A::StridedMatrix, B::UnitUpperTriangular) rmul!(A, transpose(B)) +@deprecate A_mul_Bt!(A::StridedMatrix, B::UpperTriangular) rmul!(A, transpose(B)) +@deprecate A_mul_Bc!(A::StridedMatrix, B::UnitLowerTriangular) rmul!(A, adjoint(B)) +@deprecate A_mul_Bc!(A::StridedMatrix, B::LowerTriangular) rmul!(A, adjoint(B)) +@deprecate A_mul_Bc!(A::StridedMatrix, B::UnitUpperTriangular) rmul!(A, adjoint(B)) +@deprecate A_mul_Bc!(A::StridedMatrix, B::UpperTriangular) rmul!(A, adjoint(B)) +@deprecate A_mul_B!(A::StridedMatrix, B::UnitLowerTriangular) rmul!(A, B) +@deprecate A_mul_B!(A::StridedMatrix, B::LowerTriangular) rmul!(A, B) +@deprecate A_mul_B!(A::StridedMatrix, B::UnitUpperTriangular) rmul!(A, B) +@deprecate A_mul_B!(A::StridedMatrix, B::UpperTriangular) rmul!(A, B) +@deprecate At_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) lmul!(transpose(A), B) +@deprecate At_mul_B!(A::LowerTriangular, B::StridedVecOrMat) lmul!(transpose(A), B) +@deprecate At_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) lmul!(transpose(A), B) +@deprecate At_mul_B!(A::UpperTriangular, B::StridedVecOrMat) lmul!(transpose(A), B) +@deprecate Ac_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) lmul!(adjoint(A), B) +@deprecate Ac_mul_B!(A::LowerTriangular, B::StridedVecOrMat) lmul!(adjoint(A), B) +@deprecate Ac_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) lmul!(adjoint(A), B) +@deprecate Ac_mul_B!(A::UpperTriangular, B::StridedVecOrMat) lmul!(adjoint(A), B) +@deprecate A_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat) lmul!(A, B) +@deprecate A_mul_B!(A::LowerTriangular, B::StridedVecOrMat) lmul!(A, B) +@deprecate A_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat) lmul!(A, B) +@deprecate A_mul_B!(A::UpperTriangular, B::StridedVecOrMat) lmul!(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) @@ -1045,7 +1045,7 @@ end @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) mul2!(A, B) +@deprecate A_mul_B!(A::Tridiagonal, B::AbstractTriangular) lmul!(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)) @@ -1097,22 +1097,22 @@ for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'), (:UnitUpperTriangular, 'U', 'U')) @eval begin # Vector multiplication - @deprecate A_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} mul2!(A, b) - @deprecate At_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} mul2!(transpose(A), b) - @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasReal} mul2!(adjoint(A), b) - @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasComplex} mul2!(adjoint(A), b) + @deprecate A_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} lmul!(A, b) + @deprecate At_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} lmul!(transpose(A), b) + @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasReal} lmul!(adjoint(A), b) + @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasComplex} lmul!(adjoint(A), b) # Matrix multiplication - @deprecate A_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} mul2!(A, B) - @deprecate A_mul_B!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} mul2!(A, B) + @deprecate A_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} lmul!(A, B) + @deprecate A_mul_B!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} lmul!(A, B) - @deprecate At_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} mul2!(transpose(A), B) - @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasComplex} mul2!(adjoint(A), B) - @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasReal} mul2!(adjoint(A), B) + @deprecate At_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} lmul!(transpose(A), B) + @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasComplex} lmul!(adjoint(A), B) + @deprecate Ac_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasReal} lmul!(adjoint(A), B) - @deprecate A_mul_Bt!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} mul1!(A, transpose(B)) - @deprecate A_mul_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasComplex} mul1!(A, adjoint(B)) - @deprecate A_mul_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasReal} mul1!(A, adjoint(B)) + @deprecate A_mul_Bt!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} rmul!(A, transpose(B)) + @deprecate A_mul_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasComplex} rmul!(A, adjoint(B)) + @deprecate A_mul_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasReal} rmul!(A, adjoint(B)) # Left division @deprecate A_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} ldiv!(A, B) @@ -1170,11 +1170,11 @@ end @deprecate A_mul_Bt(mat::AbstractMatrix, rowvec::RowVector) (*)(mat, transpose(rowvec)) # A[ct]_(mul|ldiv|rdiv)_B[ct][!] methods from base/linalg/givens.jl, to deprecate -@deprecate A_mul_Bc!(A::AbstractMatrix, R::Rotation) mul1!(A, adjoint(R)) -@deprecate A_mul_B!(R::Rotation, A::AbstractMatrix) mul2!(R, A) -@deprecate A_mul_B!(G::Givens, R::Rotation) mul2!(G, R) -@deprecate A_mul_Bc!(A::AbstractMatrix, G::Givens) mul1!(A, adjoint(G)) -@deprecate A_mul_B!(G::Givens, A::AbstractVecOrMat) mul2!(G, A) +@deprecate A_mul_Bc!(A::AbstractMatrix, R::Rotation) rmul!(A, adjoint(R)) +@deprecate A_mul_B!(R::Rotation, A::AbstractMatrix) lmul!(R, A) +@deprecate A_mul_B!(G::Givens, R::Rotation) lmul!(G, R) +@deprecate A_mul_Bc!(A::AbstractMatrix, G::Givens) rmul!(A, adjoint(G)) +@deprecate A_mul_B!(G::Givens, A::AbstractVecOrMat) lmul!(G, A) @deprecate A_mul_B!(G1::Givens, G2::Givens) G1 * G2 @deprecate A_mul_Bc(A::AbstractVecOrMat{T}, R::AbstractRotation{S}) where {T,S} (*)(A, adjoint(R)) @@ -1254,9 +1254,9 @@ end @deprecate getq(F::Factorization) F.Q # Deprecate scaling -@deprecate scale!(A::AbstractArray, b::Number) mul1!(A, b) -@deprecate scale!(a::Number, B::AbstractArray) mul2!(a, B) -@deprecate scale!(A::AbstractMatrix, b::AbstractVector) mul1!(A, Diagonal(b)) -@deprecate scale!(a::AbstractVector, B::AbstractMatrix) mul2!(Diagonal(a), B) +@deprecate scale!(A::AbstractArray, b::Number) rmul!(A, b) +@deprecate scale!(a::Number, B::AbstractArray) lmul!(a, B) +@deprecate scale!(A::AbstractMatrix, b::AbstractVector) rmul!(A, Diagonal(b)) +@deprecate scale!(a::AbstractVector, B::AbstractMatrix) lmul!(Diagonal(a), B) @deprecate scale!(C::AbstractMatrix, A::AbstractMatrix, b::AbstractVector) mul!(C, A, Diagonal(b)) @deprecate scale!(C::AbstractMatrix, a::AbstractVector, B::AbstractMatrix) mul!(C, Diagonal(a), B) diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl index beb4921780eb6..9f7fa754b01a0 100644 --- a/stdlib/LinearAlgebra/src/diagonal.jl +++ b/stdlib/LinearAlgebra/src/diagonal.jl @@ -151,49 +151,49 @@ end (*)(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag .* Db.diag) (*)(D::Diagonal, V::AbstractVector) = D.diag .* V -(*)(A::AbstractTriangular, D::Diagonal) = mul1!(copy(A), D) -(*)(D::Diagonal, B::AbstractTriangular) = mul2!(D, copy(B)) +(*)(A::AbstractTriangular, D::Diagonal) = rmul!(copy(A), D) +(*)(D::Diagonal, B::AbstractTriangular) = lmul!(D, copy(B)) (*)(A::AbstractMatrix, D::Diagonal) = mul!(similar(A, promote_op(*, eltype(A), eltype(D.diag)), size(A)), A, D) (*)(D::Diagonal, A::AbstractMatrix) = mul!(similar(A, promote_op(*, eltype(A), eltype(D.diag)), size(A)), D, A) -function mul1!(A::AbstractMatrix, D::Diagonal) +function rmul!(A::AbstractMatrix, D::Diagonal) A .= A .* transpose(D.diag) return A end -function mul2!(D::Diagonal, B::AbstractMatrix) +function lmul!(D::Diagonal, B::AbstractMatrix) B .= D.diag .* B return B end -mul1!(A::Union{LowerTriangular,UpperTriangular}, D::Diagonal) = typeof(A)(mul1!(A.data, D)) -function mul1!(A::UnitLowerTriangular, D::Diagonal) - mul1!(A.data, D) +rmul!(A::Union{LowerTriangular,UpperTriangular}, D::Diagonal) = typeof(A)(rmul!(A.data, D)) +function rmul!(A::UnitLowerTriangular, D::Diagonal) + rmul!(A.data, D) for i = 1:size(A, 1) A.data[i,i] = D.diag[i] end LowerTriangular(A.data) end -function mul1!(A::UnitUpperTriangular, D::Diagonal) - mul1!(A.data, D) +function rmul!(A::UnitUpperTriangular, D::Diagonal) + rmul!(A.data, D) for i = 1:size(A, 1) A.data[i,i] = D.diag[i] end UpperTriangular(A.data) end -function mul2!(D::Diagonal, B::UnitLowerTriangular) - mul2!(D, B.data) +function lmul!(D::Diagonal, B::UnitLowerTriangular) + lmul!(D, B.data) for i = 1:size(B, 1) B.data[i,i] = D.diag[i] end LowerTriangular(B.data) end -function mul2!(D::Diagonal, B::UnitUpperTriangular) - mul2!(D, B.data) +function lmul!(D::Diagonal, B::UnitUpperTriangular) + lmul!(D, B.data) for i = 1:size(B, 1) B.data[i,i] = D.diag[i] end @@ -201,40 +201,40 @@ function mul2!(D::Diagonal, B::UnitUpperTriangular) end *(D::Adjoint{<:Any,<:Diagonal}, B::Diagonal) = Diagonal(adjoint.(D.parent.diag) .* B.diag) -*(A::Adjoint{<:Any,<:AbstractTriangular}, D::Diagonal) = mul1!(copy(A), D) +*(A::Adjoint{<:Any,<:AbstractTriangular}, D::Diagonal) = rmul!(copy(A), D) function *(adjA::Adjoint{<:Any,<:AbstractMatrix}, D::Diagonal) A = adjA.parent Ac = similar(A, promote_op(*, eltype(A), eltype(D.diag)), (size(A, 2), size(A, 1))) adjoint!(Ac, A) - mul1!(Ac, D) + rmul!(Ac, D) end *(D::Transpose{<:Any,<:Diagonal}, B::Diagonal) = Diagonal(transpose.(D.parent.diag) .* B.diag) -*(A::Transpose{<:Any,<:AbstractTriangular}, D::Diagonal) = mul1!(copy(A), D) +*(A::Transpose{<:Any,<:AbstractTriangular}, D::Diagonal) = rmul!(copy(A), D) function *(transA::Transpose{<:Any,<:AbstractMatrix}, D::Diagonal) A = transA.parent At = similar(A, promote_op(*, eltype(A), eltype(D.diag)), (size(A, 2), size(A, 1))) transpose!(At, A) - mul1!(At, D) + rmul!(At, D) end *(D::Diagonal, B::Adjoint{<:Any,<:Diagonal}) = Diagonal(D.diag .* adjoint.(B.parent.diag)) -*(D::Diagonal, B::Adjoint{<:Any,<:AbstractTriangular}) = mul2!(D, collect(B)) -*(D::Diagonal, adjQ::Adjoint{<:Any,<:Union{QRCompactWYQ,QRPackedQ}}) = (Q = adjQ.parent; mul1!(Array(D), adjoint(Q))) +*(D::Diagonal, B::Adjoint{<:Any,<:AbstractTriangular}) = lmul!(D, collect(B)) +*(D::Diagonal, adjQ::Adjoint{<:Any,<:Union{QRCompactWYQ,QRPackedQ}}) = (Q = adjQ.parent; rmul!(Array(D), adjoint(Q))) function *(D::Diagonal, adjA::Adjoint{<:Any,<:AbstractMatrix}) A = adjA.parent Ac = similar(A, promote_op(*, eltype(A), eltype(D.diag)), (size(A, 2), size(A, 1))) adjoint!(Ac, A) - mul2!(D, Ac) + lmul!(D, Ac) end *(D::Diagonal, B::Transpose{<:Any,<:Diagonal}) = Diagonal(D.diag .* transpose.(B.parent.diag)) -*(D::Diagonal, B::Transpose{<:Any,<:AbstractTriangular}) = mul2!(D, copy(B)) +*(D::Diagonal, B::Transpose{<:Any,<:AbstractTriangular}) = lmul!(D, copy(B)) function *(D::Diagonal, transA::Transpose{<:Any,<:AbstractMatrix}) A = transA.parent At = similar(A, promote_op(*, eltype(A), eltype(D.diag)), (size(A, 2), size(A, 1))) transpose!(At, A) - mul2!(D, At) + lmul!(D, At) end *(D::Adjoint{<:Any,<:Diagonal}, B::Adjoint{<:Any,<:Diagonal}) = @@ -242,25 +242,25 @@ end *(D::Transpose{<:Any,<:Diagonal}, B::Transpose{<:Any,<:Diagonal}) = Diagonal(transpose.(D.parent.diag) .* transpose.(B.parent.diag)) -mul1!(A::Diagonal, B::Diagonal) = Diagonal(A.diag .*= B.diag) -mul2!(A::Diagonal, B::Diagonal) = Diagonal(B.diag .= A.diag .* B.diag) +rmul!(A::Diagonal, B::Diagonal) = Diagonal(A.diag .*= B.diag) +lmul!(A::Diagonal, B::Diagonal) = Diagonal(B.diag .= A.diag .* B.diag) -function mul2!(adjA::Adjoint{<:Any,<:Diagonal}, B::AbstractMatrix) +function lmul!(adjA::Adjoint{<:Any,<:Diagonal}, B::AbstractMatrix) A = adjA.parent - return mul2!(conj(A.diag), B) + return lmul!(conj(A.diag), B) end -function mul2!(transA::Transpose{<:Any,<:Diagonal}, B::AbstractMatrix) +function lmul!(transA::Transpose{<:Any,<:Diagonal}, B::AbstractMatrix) A = transA.parent - return mul2!(A.diag, B) + return lmul!(A.diag, B) end -function mul1!(A::AbstractMatrix, adjB::Adjoint{<:Any,<:Diagonal}) +function rmul!(A::AbstractMatrix, adjB::Adjoint{<:Any,<:Diagonal}) B = adjB.parent - return mul1!(A, conj(B.diag)) + return rmul!(A, conj(B.diag)) end -function mul1!(A::AbstractMatrix, transB::Transpose{<:Any,<:Diagonal}) +function rmul!(A::AbstractMatrix, transB::Transpose{<:Any,<:Diagonal}) B = transB.parent - return mul1!(A, B.diag) + return rmul!(A, B.diag) end # Get ambiguous method if try to unify AbstractVector/AbstractMatrix here using AbstractVecOrMat diff --git a/stdlib/LinearAlgebra/src/generic.jl b/stdlib/LinearAlgebra/src/generic.jl index 792fbbc39e044..b14480aa2b8d6 100644 --- a/stdlib/LinearAlgebra/src/generic.jl +++ b/stdlib/LinearAlgebra/src/generic.jl @@ -4,14 +4,14 @@ # For better performance when input and output are the same array # See https://github.com/JuliaLang/julia/issues/8415#issuecomment-56608729 -function generic_mul1!(X::AbstractArray, s::Number) +function generic_rmul!(X::AbstractArray, s::Number) @simd for I in eachindex(X) @inbounds X[I] *= s end X end -function generic_mul2!(s::Number, X::AbstractArray) +function generic_lmul!(s::Number, X::AbstractArray) @simd for I in eachindex(X) @inbounds X[I] = s*X[I] end @@ -43,7 +43,7 @@ mul!(C::AbstractArray, s::Number, X::AbstractArray) = generic_mul!(C, X, s) mul!(C::AbstractArray, X::AbstractArray, s::Number) = generic_mul!(C, s, X) """ - mul1!(A::AbstractArray, b::Number) + rmul!(A::AbstractArray, b::Number) Scale an array `A` by a scalar `b` overwriting `A` in-place. @@ -54,16 +54,16 @@ julia> A = [1 2; 3 4] 1 2 3 4 -julia> mul1!(A, 2) +julia> rmul!(A, 2) 2×2 Array{Int64,2}: 2 4 6 8 ``` """ -mul1!(A::AbstractArray, b::Number) = generic_mul1!(A, b) +rmul!(A::AbstractArray, b::Number) = generic_rmul!(A, b) """ - mul2!(a::Number, B::AbstractArray) + lmul!(a::Number, B::AbstractArray) Scale an array `B` by a scalar `a` overwriting `B` in-place. @@ -74,13 +74,13 @@ julia> B = [1 2; 3 4] 1 2 3 4 -julia> mul2!(2, B) +julia> lmul!(2, B) 2×2 Array{Int64,2}: 2 4 6 8 ``` """ -mul2!(a::Number, B::AbstractArray) = generic_mul2!(a, B) +lmul!(a::Number, B::AbstractArray) = generic_lmul!(a, B) """ cross(x, y) @@ -1439,12 +1439,12 @@ end if nrm ≥ δ # Safe to multiply with inverse invnrm = inv(nrm) - mul1!(v, invnrm) + rmul!(v, invnrm) else # scale elements to avoid overflow εδ = eps(one(nrm))/δ - mul1!(v, εδ) - mul1!(v, inv(nrm*εδ)) + rmul!(v, εδ) + rmul!(v, inv(nrm*εδ)) end v diff --git a/stdlib/LinearAlgebra/src/givens.jl b/stdlib/LinearAlgebra/src/givens.jl index 9b508d5e1677c..6569ac4aadc7a 100644 --- a/stdlib/LinearAlgebra/src/givens.jl +++ b/stdlib/LinearAlgebra/src/givens.jl @@ -7,14 +7,14 @@ transpose(R::AbstractRotation) = error("transpose not implemented for $(typeof(R function *(R::AbstractRotation{T}, A::AbstractVecOrMat{S}) where {T,S} TS = typeof(zero(T)*zero(S) + zero(T)*zero(S)) - mul2!(convert(AbstractRotation{TS}, R), TS == S ? copy(A) : convert(AbstractArray{TS}, A)) + lmul!(convert(AbstractRotation{TS}, R), TS == S ? copy(A) : convert(AbstractArray{TS}, A)) end *(A::AbstractVector, adjR::Adjoint{<:Any,<:AbstractRotation}) = _absvecormat_mul_adjrot(A, adjR) *(A::AbstractMatrix, adjR::Adjoint{<:Any,<:AbstractRotation}) = _absvecormat_mul_adjrot(A, adjR) function _absvecormat_mul_adjrot(A::AbstractVecOrMat{T}, adjR::Adjoint{<:Any,<:AbstractRotation{S}}) where {T,S} R = adjR.parent TS = typeof(zero(T)*zero(S) + zero(T)*zero(S)) - mul1!(TS == T ? copy(A) : convert(AbstractArray{TS}, A), adjoint(convert(AbstractRotation{TS}, R))) + rmul!(TS == T ? copy(A) : convert(AbstractArray{TS}, A), adjoint(convert(AbstractRotation{TS}, R))) end """ LinearAlgebra.Givens(i1,i2,c,s) -> G @@ -325,7 +325,7 @@ function getindex(G::Givens, i::Integer, j::Integer) end end -function mul2!(G::Givens, A::AbstractVecOrMat) +function lmul!(G::Givens, A::AbstractVecOrMat) m, n = size(A, 1), size(A, 2) if G.i2 > m throw(DimensionMismatch("column indices for rotation are outside the matrix")) @@ -337,7 +337,7 @@ function mul2!(G::Givens, A::AbstractVecOrMat) end return A end -function mul1!(A::AbstractMatrix, adjG::Adjoint{<:Any,<:Givens}) +function rmul!(A::AbstractMatrix, adjG::Adjoint{<:Any,<:Givens}) G = adjG.parent m, n = size(A, 1), size(A, 2) if G.i2 > n @@ -351,20 +351,20 @@ function mul1!(A::AbstractMatrix, adjG::Adjoint{<:Any,<:Givens}) return A end -function mul2!(G::Givens, R::Rotation) +function lmul!(G::Givens, R::Rotation) push!(R.rotations, G) return R end -function mul2!(R::Rotation, A::AbstractMatrix) +function lmul!(R::Rotation, A::AbstractMatrix) @inbounds for i = 1:length(R.rotations) - mul2!(R.rotations[i], A) + lmul!(R.rotations[i], A) end return A end -function mul1!(A::AbstractMatrix, adjR::Adjoint{<:Any,<:Rotation}) +function rmul!(A::AbstractMatrix, adjR::Adjoint{<:Any,<:Rotation}) R = adjR.parent @inbounds for i = 1:length(R.rotations) - mul1!(A, adjoint(R.rotations[i])) + rmul!(A, adjoint(R.rotations[i])) end return A end diff --git a/stdlib/LinearAlgebra/src/hessenberg.jl b/stdlib/LinearAlgebra/src/hessenberg.jl index 18a098f1fb8f7..54be7719dcda0 100644 --- a/stdlib/LinearAlgebra/src/hessenberg.jl +++ b/stdlib/LinearAlgebra/src/hessenberg.jl @@ -73,7 +73,7 @@ function getindex(A::HessenbergQ, i::Integer, j::Integer) x[i] = 1 y = zeros(eltype(A), size(A, 2)) y[j] = 1 - return dot(x, mul2!(A, y)) + return dot(x, lmul!(A, y)) end ## reconstruct the original matrix @@ -84,30 +84,30 @@ AbstractArray(F::Hessenberg) = AbstractMatrix(F) Matrix(F::Hessenberg) = Array(AbstractArray(F)) Array(F::Hessenberg) = Matrix(F) -mul2!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} = +lmul!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} = LAPACK.ormhr!('L', 'N', 1, size(Q.factors, 1), Q.factors, Q.τ, X) -mul1!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} = +rmul!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} = LAPACK.ormhr!('R', 'N', 1, size(Q.factors, 1), Q.factors, Q.τ, X) -mul2!(adjQ::Adjoint{<:Any,<:HessenbergQ{T}}, X::StridedVecOrMat{T}) where {T<:BlasFloat} = +lmul!(adjQ::Adjoint{<:Any,<:HessenbergQ{T}}, X::StridedVecOrMat{T}) where {T<:BlasFloat} = (Q = adjQ.parent; LAPACK.ormhr!('L', ifelse(T<:Real, 'T', 'C'), 1, size(Q.factors, 1), Q.factors, Q.τ, X)) -mul1!(X::StridedMatrix{T}, adjQ::Adjoint{<:Any,<:HessenbergQ{T}}) where {T<:BlasFloat} = +rmul!(X::StridedMatrix{T}, adjQ::Adjoint{<:Any,<:HessenbergQ{T}}) where {T<:BlasFloat} = (Q = adjQ.parent; LAPACK.ormhr!('R', ifelse(T<:Real, 'T', 'C'), 1, size(Q.factors, 1), Q.factors, Q.τ, X)) function (*)(Q::HessenbergQ{T}, X::StridedVecOrMat{S}) where {T,S} TT = typeof(zero(T)*zero(S) + zero(T)*zero(S)) - return mul2!(Q, copy_oftype(X, TT)) + return lmul!(Q, copy_oftype(X, TT)) end function (*)(X::StridedVecOrMat{S}, Q::HessenbergQ{T}) where {T,S} TT = typeof(zero(T)*zero(S) + zero(T)*zero(S)) - return mul1!(copy_oftype(X, TT), Q) + return rmul!(copy_oftype(X, TT), Q) end function *(adjQ::Adjoint{<:Any,<:HessenbergQ{T}}, X::StridedVecOrMat{S}) where {T,S} Q = adjQ.parent TT = typeof(zero(T)*zero(S) + zero(T)*zero(S)) - return mul2!(adjoint(Q), copy_oftype(X, TT)) + return lmul!(adjoint(Q), copy_oftype(X, TT)) end function *(X::StridedVecOrMat{S}, adjQ::Adjoint{<:Any,<:HessenbergQ{T}}) where {T,S} Q = adjQ.parent TT = typeof(zero(T)*zero(S) + zero(T)*zero(S)) - return mul1!(copy_oftype(X, TT), adjoint(Q)) + return rmul!(copy_oftype(X, TT), adjoint(Q)) end diff --git a/stdlib/LinearAlgebra/src/lq.jl b/stdlib/LinearAlgebra/src/lq.jl index 7197c3cfb9d8b..4bea24b582250 100644 --- a/stdlib/LinearAlgebra/src/lq.jl +++ b/stdlib/LinearAlgebra/src/lq.jl @@ -57,7 +57,7 @@ function lq(A::Union{Number,AbstractMatrix}; full::Bool = false, thin::Union{Boo end F = lqfact(A) L, Q = F.L, F.Q - return L, !full ? Array(Q) : mul2!(Q, Matrix{eltype(Q)}(I, size(Q.factors, 2), size(Q.factors, 2))) + return L, !full ? Array(Q) : lmul!(Q, Matrix{eltype(Q)}(I, size(Q.factors, 2), size(Q.factors, 2))) end copy(A::LQ) = LQ(copy(A.factors), copy(A.τ)) @@ -88,7 +88,7 @@ end Base.propertynames(F::LQ, private::Bool=false) = append!([:L,:Q], private ? fieldnames(typeof(F)) : Symbol[]) getindex(A::LQPackedQ, i::Integer, j::Integer) = - mul2!(A, setindex!(zeros(eltype(A), size(A, 2)), 1, j))[i] + lmul!(A, setindex!(zeros(eltype(A), size(A, 2)), 1, j))[i] function show(io::IO, C::LQ) println(io, "$(typeof(C)) with factors L and Q:") @@ -122,34 +122,34 @@ end ## Multiplication by LQ -mul2!(A::LQ, B::StridedVecOrMat) = - mul2!(LowerTriangular(A.L), mul2!(A.Q, B)) +lmul!(A::LQ, B::StridedVecOrMat) = + lmul!(LowerTriangular(A.L), lmul!(A.Q, B)) function *(A::LQ{TA}, B::StridedVecOrMat{TB}) where {TA,TB} TAB = promote_type(TA, TB) - mul2!(Factorization{TAB}(A), copy_oftype(B, TAB)) + lmul!(Factorization{TAB}(A), copy_oftype(B, TAB)) end ## Multiplication by Q ### QB -mul2!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = LAPACK.ormlq!('L','N',A.factors,A.τ,B) +lmul!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = LAPACK.ormlq!('L','N',A.factors,A.τ,B) function (*)(A::LQPackedQ, B::StridedVecOrMat) TAB = promote_type(eltype(A), eltype(B)) - mul2!(AbstractMatrix{TAB}(A), copy_oftype(B, TAB)) + lmul!(AbstractMatrix{TAB}(A), copy_oftype(B, TAB)) end ### QcB -mul2!(adjA::Adjoint{<:Any,<:LQPackedQ{T}}, B::StridedVecOrMat{T}) where {T<:BlasReal} = +lmul!(adjA::Adjoint{<:Any,<:LQPackedQ{T}}, B::StridedVecOrMat{T}) where {T<:BlasReal} = (A = adjA.parent; LAPACK.ormlq!('L','T',A.factors,A.τ,B)) -mul2!(adjA::Adjoint{<:Any,<:LQPackedQ{T}}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = +lmul!(adjA::Adjoint{<:Any,<:LQPackedQ{T}}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = (A = adjA.parent; LAPACK.ormlq!('L','C',A.factors,A.τ,B)) function *(adjA::Adjoint{<:Any,<:LQPackedQ}, B::StridedVecOrMat) A = adjA.parent TAB = promote_type(eltype(A), eltype(B)) if size(B,1) == size(A.factors,2) - mul2!(adjoint(AbstractMatrix{TAB}(A)), copy_oftype(B, TAB)) + lmul!(adjoint(AbstractMatrix{TAB}(A)), copy_oftype(B, TAB)) elseif size(B,1) == size(A.factors,1) - mul2!(adjoint(AbstractMatrix{TAB}(A)), [B; zeros(TAB, size(A.factors, 2) - size(A.factors, 1), size(B, 2))]) + lmul!(adjoint(AbstractMatrix{TAB}(A)), [B; zeros(TAB, size(A.factors, 2) - size(A.factors, 1), size(B, 2))]) else throw(DimensionMismatch("first dimension of B, $(size(B,1)), must equal one of the dimensions of A, $(size(A))")) end @@ -161,14 +161,14 @@ function *(A::LQPackedQ, adjB::Adjoint{<:Any,<:StridedVecOrMat}) TAB = promote_type(eltype(A), eltype(B)) BB = similar(B, TAB, (size(B, 2), size(B, 1))) adjoint!(BB, B) - return mul2!(A, BB) + return lmul!(A, BB) end function *(adjA::Adjoint{<:Any,<:LQPackedQ}, adjB::Adjoint{<:Any,<:StridedVecOrMat}) A, B = adjA.parent, adjB.parent TAB = promote_type(eltype(A), eltype(B)) BB = similar(B, TAB, (size(B, 2), size(B, 1))) adjoint!(BB, B) - return mul2!(adjoint(A), BB) + return lmul!(adjoint(A), BB) end # in-place right-application of LQPackedQs @@ -176,11 +176,11 @@ end # match the number of columns (nQ) of the LQPackedQ (Q) (necessary for in-place # operation, and the underlying LAPACK routine (ormlq) treats the implicit Q # as its (nQ-by-nQ) square form) -mul1!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasFloat} = +rmul!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasFloat} = LAPACK.ormlq!('R', 'N', B.factors, B.τ, A) -mul1!(A::StridedMatrix{T}, adjB::Adjoint{<:Any,<:LQPackedQ{T}}) where {T<:BlasReal} = +rmul!(A::StridedMatrix{T}, adjB::Adjoint{<:Any,<:LQPackedQ{T}}) where {T<:BlasReal} = (B = adjB.parent; LAPACK.ormlq!('R', 'T', B.factors, B.τ, A)) -mul1!(A::StridedMatrix{T}, adjB::Adjoint{<:Any,<:LQPackedQ{T}}) where {T<:BlasComplex} = +rmul!(A::StridedMatrix{T}, adjB::Adjoint{<:Any,<:LQPackedQ{T}}) where {T<:BlasComplex} = (B = adjB.parent; LAPACK.ormlq!('R', 'C', B.factors, B.τ, A)) # out-of-place right application of LQPackedQs @@ -198,13 +198,13 @@ mul1!(A::StridedMatrix{T}, adjB::Adjoint{<:Any,<:LQPackedQ{T}}) where {T<:BlasCo function *(A::StridedVecOrMat, adjQ::Adjoint{<:Any,<:LQPackedQ}) Q = adjQ.parent TR = promote_type(eltype(A), eltype(Q)) - return mul1!(copy_oftype(A, TR), adjoint(AbstractMatrix{TR}(Q))) + return rmul!(copy_oftype(A, TR), adjoint(AbstractMatrix{TR}(Q))) end function *(adjA::Adjoint{<:Any,<:StridedMatrix}, adjQ::Adjoint{<:Any,<:LQPackedQ}) A, Q = adjA.parent, adjQ.parent TR = promote_type(eltype(A), eltype(Q)) C = adjoint!(similar(A, TR, reverse(size(A))), A) - return mul1!(C, adjoint(AbstractMatrix{TR}(Q))) + return rmul!(C, adjoint(AbstractMatrix{TR}(Q))) end # # (2) the inner dimension in the multiplication is the LQPackedQ's first dimension. @@ -229,7 +229,7 @@ function *(A::StridedVecOrMat, Q::LQPackedQ) else _rightappdimmismatch("columns") end - return mul1!(C, AbstractMatrix{TR}(Q)) + return rmul!(C, AbstractMatrix{TR}(Q)) end function *(adjA::Adjoint{<:Any,<:StridedMatrix}, Q::LQPackedQ) A = adjA.parent @@ -242,7 +242,7 @@ function *(adjA::Adjoint{<:Any,<:StridedMatrix}, Q::LQPackedQ) else _rightappdimmismatch("rows") end - return mul1!(C, AbstractMatrix{TR}(Q)) + return rmul!(C, AbstractMatrix{TR}(Q)) end _rightappdimmismatch(rowsorcols) = throw(DimensionMismatch(string("the number of $(rowsorcols) of the matrix on the left ", @@ -278,6 +278,6 @@ end function ldiv!(A::LQ{T}, B::StridedVecOrMat{T}) where T - mul2!(adjoint(A.Q), ldiv!(LowerTriangular(A.L),B)) + lmul!(adjoint(A.Q), ldiv!(LowerTriangular(A.L),B)) return B end diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl index 16ca79e14b09a..84c31511f1730 100644 --- a/stdlib/LinearAlgebra/src/matmul.jl +++ b/stdlib/LinearAlgebra/src/matmul.jl @@ -158,18 +158,18 @@ julia> Y mul!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = generic_matmatmul!(C, 'N', 'N', A, B) """ - mul1!(A, B) + rmul!(A, B) Calculate the matrix-matrix product ``AB``, overwriting `A`, and return the result. """ -mul1!(A, B) +rmul!(A, B) """ - mul2!(A, B) + lmul!(A, B) Calculate the matrix-matrix product ``AB``, overwriting `B`, and return the result. """ -mul2!(A, B) +lmul!(A, B) function *(transA::Transpose{<:Any,<:AbstractMatrix}, B::AbstractMatrix) A = transA.parent diff --git a/stdlib/LinearAlgebra/src/qr.jl b/stdlib/LinearAlgebra/src/qr.jl index 2fdc2473e7c80..7a7964a72a1af 100644 --- a/stdlib/LinearAlgebra/src/qr.jl +++ b/stdlib/LinearAlgebra/src/qr.jl @@ -329,13 +329,13 @@ function _qr(A::Union{Number,AbstractMatrix}, ::Val{false}; full::Bool = false) F = qrfact(A, Val(false)) Q, R = F.Q, F.R sQf1 = size(Q.factors, 1) - return (!full ? Array(Q) : mul2!(Q, Matrix{eltype(Q)}(I, sQf1, sQf1))), R + return (!full ? Array(Q) : lmul!(Q, Matrix{eltype(Q)}(I, sQf1, sQf1))), R end function _qr(A::Union{Number, AbstractMatrix}, ::Val{true}; full::Bool = false) F = qrfact(A, Val(true)) Q, R, p = F.Q, F.R, F.p sQf1 = size(Q.factors, 1) - return (!full ? Array(Q) : mul2!(Q, Matrix{eltype(Q)}(I, sQf1, sQf1))), R, p + return (!full ? Array(Q) : lmul!(Q, Matrix{eltype(Q)}(I, sQf1, sQf1))), R, p end """ @@ -506,7 +506,7 @@ AbstractMatrix{T}(Q::QRPackedQ) where {T} = QRPackedQ{T}(Q) QRCompactWYQ{S}(Q::QRCompactWYQ) where {S} = QRCompactWYQ(convert(AbstractMatrix{S}, Q.factors), convert(AbstractMatrix{S}, Q.T)) AbstractMatrix{S}(Q::QRCompactWYQ{S}) where {S} = Q AbstractMatrix{S}(Q::QRCompactWYQ) where {S} = QRCompactWYQ{S}(Q) -Matrix(A::AbstractQ{T}) where {T} = mul2!(A, Matrix{T}(I, size(A.factors, 1), min(size(A.factors)...))) +Matrix(A::AbstractQ{T}) where {T} = lmul!(A, Matrix{T}(I, size(A.factors, 1), min(size(A.factors)...))) Array(A::AbstractQ) = Matrix(A) size(A::Union{QR,QRCompactWY,QRPivoted}, dim::Integer) = size(getfield(A, :factors), dim) @@ -520,16 +520,16 @@ function getindex(A::AbstractQ, i::Integer, j::Integer) x[i] = 1 y = zeros(eltype(A), size(A, 2)) y[j] = 1 - return dot(x, mul2!(A, y)) + return dot(x, lmul!(A, y)) end ## Multiplication by Q ### QB -mul2!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} = +lmul!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} = LAPACK.gemqrt!('L','N',A.factors,A.T,B) -mul2!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} = +lmul!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} = LAPACK.ormqr!('L','N',A.factors,A.τ,B) -function mul2!(A::QRPackedQ, B::AbstractVecOrMat) +function lmul!(A::QRPackedQ, B::AbstractVecOrMat) mA, nA = size(A.factors) mB, nB = size(B,1), size(B,2) if mA != mB @@ -564,7 +564,7 @@ function (*)(A::AbstractQ, b::StridedVector) else throw(DimensionMismatch("vector must have length either $(size(A.factors, 1)) or $(size(A.factors, 2))")) end - mul2!(Anew, bnew) + lmul!(Anew, bnew) end function (*)(A::AbstractQ, B::StridedMatrix) TAB = promote_type(eltype(A), eltype(B)) @@ -576,19 +576,19 @@ function (*)(A::AbstractQ, B::StridedMatrix) else throw(DimensionMismatch("first dimension of matrix must have size either $(size(A.factors, 1)) or $(size(A.factors, 2))")) end - mul2!(Anew, Bnew) + lmul!(Anew, Bnew) end ### QcB -mul2!(adjA::Adjoint{<:Any,<:QRCompactWYQ{T,S}}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} = +lmul!(adjA::Adjoint{<:Any,<:QRCompactWYQ{T,S}}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} = (A = adjA.parent; LAPACK.gemqrt!('L','T',A.factors,A.T,B)) -mul2!(adjA::Adjoint{<:Any,<:QRCompactWYQ{T,S}}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} = +lmul!(adjA::Adjoint{<:Any,<:QRCompactWYQ{T,S}}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} = (A = adjA.parent; LAPACK.gemqrt!('L','C',A.factors,A.T,B)) -mul2!(adjA::Adjoint{<:Any,<:QRPackedQ{T,S}}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} = +lmul!(adjA::Adjoint{<:Any,<:QRPackedQ{T,S}}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} = (A = adjA.parent; LAPACK.ormqr!('L','T',A.factors,A.τ,B)) -mul2!(adjA::Adjoint{<:Any,<:QRPackedQ{T,S}}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} = +lmul!(adjA::Adjoint{<:Any,<:QRPackedQ{T,S}}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} = (A = adjA.parent; LAPACK.ormqr!('L','C',A.factors,A.τ,B)) -function mul2!(adjA::Adjoint{<:Any,<:QRPackedQ}, B::AbstractVecOrMat) +function lmul!(adjA::Adjoint{<:Any,<:QRPackedQ}, B::AbstractVecOrMat) A = adjA.parent mA, nA = size(A.factors) mB, nB = size(B,1), size(B,2) @@ -616,7 +616,7 @@ end function *(adjQ::Adjoint{<:Any,<:AbstractQ}, B::StridedVecOrMat) Q = adjQ.parent TQB = promote_type(eltype(Q), eltype(B)) - return mul2!(adjoint(convert(AbstractMatrix{TQB}, Q)), copy_oftype(B, TQB)) + return lmul!(adjoint(convert(AbstractMatrix{TQB}, Q)), copy_oftype(B, TQB)) end ### QBc/QcBc @@ -625,22 +625,22 @@ function *(Q::AbstractQ, adjB::Adjoint{<:Any,<:StridedVecOrMat}) TQB = promote_type(eltype(Q), eltype(B)) Bc = similar(B, TQB, (size(B, 2), size(B, 1))) adjoint!(Bc, B) - return mul2!(convert(AbstractMatrix{TQB}, Q), Bc) + return lmul!(convert(AbstractMatrix{TQB}, Q), Bc) end function *(adjQ::Adjoint{<:Any,<:AbstractQ}, adjB::Adjoint{<:Any,<:StridedVecOrMat}) Q, B = adjQ.parent, adjB.parent TQB = promote_type(eltype(Q), eltype(B)) Bc = similar(B, TQB, (size(B, 2), size(B, 1))) adjoint!(Bc, B) - return mul2!(adjoint(convert(AbstractMatrix{TQB}, Q)), Bc) + return lmul!(adjoint(convert(AbstractMatrix{TQB}, Q)), Bc) end ### AQ -mul1!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} = +rmul!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} = LAPACK.gemqrt!('R','N', B.factors, B.T, A) -mul1!(A::StridedVecOrMat{T}, B::QRPackedQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} = +rmul!(A::StridedVecOrMat{T}, B::QRPackedQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} = LAPACK.ormqr!('R', 'N', B.factors, B.τ, A) -function mul1!(A::StridedMatrix,Q::QRPackedQ) +function rmul!(A::StridedMatrix,Q::QRPackedQ) mQ, nQ = size(Q.factors) mA, nA = size(A,1), size(A,2) if nA != mQ @@ -668,19 +668,19 @@ end function (*)(A::StridedMatrix, Q::AbstractQ) TAQ = promote_type(eltype(A), eltype(Q)) - return mul1!(copy_oftype(A, TAQ), convert(AbstractMatrix{TAQ}, Q)) + return rmul!(copy_oftype(A, TAQ), convert(AbstractMatrix{TAQ}, Q)) end ### AQc -mul1!(A::StridedVecOrMat{T}, adjB::Adjoint{<:Any,<:QRCompactWYQ{T}}) where {T<:BlasReal} = +rmul!(A::StridedVecOrMat{T}, adjB::Adjoint{<:Any,<:QRCompactWYQ{T}}) where {T<:BlasReal} = (B = adjB.parent; LAPACK.gemqrt!('R','T',B.factors,B.T,A)) -mul1!(A::StridedVecOrMat{T}, adjB::Adjoint{<:Any,<:QRCompactWYQ{T}}) where {T<:BlasComplex} = +rmul!(A::StridedVecOrMat{T}, adjB::Adjoint{<:Any,<:QRCompactWYQ{T}}) where {T<:BlasComplex} = (B = adjB.parent; LAPACK.gemqrt!('R','C',B.factors,B.T,A)) -mul1!(A::StridedVecOrMat{T}, adjB::Adjoint{<:Any,<:QRPackedQ{T}}) where {T<:BlasReal} = +rmul!(A::StridedVecOrMat{T}, adjB::Adjoint{<:Any,<:QRPackedQ{T}}) where {T<:BlasReal} = (B = adjB.parent; LAPACK.ormqr!('R','T',B.factors,B.τ,A)) -mul1!(A::StridedVecOrMat{T}, adjB::Adjoint{<:Any,<:QRPackedQ{T}}) where {T<:BlasComplex} = +rmul!(A::StridedVecOrMat{T}, adjB::Adjoint{<:Any,<:QRPackedQ{T}}) where {T<:BlasComplex} = (B = adjB.parent; LAPACK.ormqr!('R','C',B.factors,B.τ,A)) -function mul1!(A::StridedMatrix, adjQ::Adjoint{<:Any,<:QRPackedQ}) +function rmul!(A::StridedMatrix, adjQ::Adjoint{<:Any,<:QRPackedQ}) Q = adjQ.parent mQ, nQ = size(Q.factors) mA, nA = size(A,1), size(A,2) @@ -712,9 +712,9 @@ function *(A::StridedMatrix, adjB::Adjoint{<:Any,<:AbstractQ}) if size(A,2) == size(B.factors, 1) AA = similar(A, TAB, size(A)) copyto!(AA, A) - return mul1!(AA, adjoint(BB)) + return rmul!(AA, adjoint(BB)) elseif size(A,2) == size(B.factors,2) - return mul1!([A zeros(TAB, size(A, 1), size(B.factors, 1) - size(B.factors, 2))], adjoint(BB)) + return rmul!([A zeros(TAB, size(A, 1), size(B.factors, 1) - size(B.factors, 2))], adjoint(BB)) else throw(DimensionMismatch("matrix A has dimensions $(size(A)) but matrix B has dimensions $(size(B))")) end @@ -728,20 +728,20 @@ function *(adjA::Adjoint{<:Any,<:StridedVecOrMat}, Q::AbstractQ) TAQ = promote_type(eltype(A), eltype(Q)) Ac = similar(A, TAQ, (size(A, 2), size(A, 1))) adjoint!(Ac, A) - return mul1!(Ac, convert(AbstractMatrix{TAQ}, Q)) + return rmul!(Ac, convert(AbstractMatrix{TAQ}, Q)) end function *(adjA::Adjoint{<:Any,<:StridedVecOrMat}, adjQ::Adjoint{<:Any,<:AbstractQ}) A, Q = adjA.parent, adjQ.parent TAQ = promote_type(eltype(A), eltype(Q)) Ac = similar(A, TAQ, (size(A, 2), size(A, 1))) adjoint!(Ac, A) - return mul1!(Ac, adjoint(convert(AbstractMatrix{TAQ}, Q))) + return rmul!(Ac, adjoint(convert(AbstractMatrix{TAQ}, Q))) end ldiv!(A::QRCompactWY{T}, b::StridedVector{T}) where {T<:BlasFloat} = - (ldiv!(UpperTriangular(A.R), view(mul2!(adjoint(A.Q), b), 1:size(A, 2))); b) + (ldiv!(UpperTriangular(A.R), view(lmul!(adjoint(A.Q), b), 1:size(A, 2))); b) ldiv!(A::QRCompactWY{T}, B::StridedMatrix{T}) where {T<:BlasFloat} = - (ldiv!(UpperTriangular(A.R), view(mul2!(adjoint(A.Q), B), 1:size(A, 2), 1:size(B, 2))); B) + (ldiv!(UpperTriangular(A.R), view(lmul!(adjoint(A.Q), B), 1:size(A, 2), 1:size(B, 2))); B) # Julia implementation similar to xgelsy function ldiv!(A::QRPivoted{T}, B::StridedMatrix{T}, rcond::Real) where T<:BlasFloat @@ -773,7 +773,7 @@ function ldiv!(A::QRPivoted{T}, B::StridedMatrix{T}, rcond::Real) where T<:BlasF rnk += 1 end C, τ = LAPACK.tzrzf!(A.factors[1:rnk,:]) - ldiv!(UpperTriangular(C[1:rnk,1:rnk]),view(mul2!(adjoint(A.Q), view(B, 1:mA, 1:nrhs)), 1:rnk, 1:nrhs)) + ldiv!(UpperTriangular(C[1:rnk,1:rnk]),view(lmul!(adjoint(A.Q), view(B, 1:mA, 1:nrhs)), 1:rnk, 1:nrhs)) B[rnk+1:end,:] = zero(T) LAPACK.ormrz!('L', eltype(B)<:Complex ? 'C' : 'T', C, τ, view(B,1:nA,1:nrhs)) B[1:nA,:] = view(B, 1:nA, :)[invperm(A.p),:] @@ -787,7 +787,7 @@ function ldiv!(A::QR{T}, B::StridedMatrix{T}) where T m, n = size(A) minmn = min(m,n) mB, nB = size(B) - mul2!(adjoint(A.Q), view(B, 1:m, :)) + lmul!(adjoint(A.Q), view(B, 1:m, :)) R = A.R @inbounds begin if n > m # minimum norm solution diff --git a/stdlib/LinearAlgebra/src/special.jl b/stdlib/LinearAlgebra/src/special.jl index 06ec00d34b312..4f1e63f1612b4 100644 --- a/stdlib/LinearAlgebra/src/special.jl +++ b/stdlib/LinearAlgebra/src/special.jl @@ -118,8 +118,8 @@ for op in (:+, :-) end end -mul1!(A::AbstractTriangular, adjB::Adjoint{<:Any,<:Union{QRCompactWYQ,QRPackedQ}}) = - (B = adjB.parent; mul1!(full!(A), adjoint(B))) +rmul!(A::AbstractTriangular, adjB::Adjoint{<:Any,<:Union{QRCompactWYQ,QRPackedQ}}) = + (B = adjB.parent; rmul!(full!(A), adjoint(B))) *(A::AbstractTriangular, adjB::Adjoint{<:Any,<:Union{QRCompactWYQ,QRPackedQ}}) = (B = adjB.parent; *(copyto!(similar(parent(A)), A), adjoint(B))) diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl index 16c0b74e51916..54baf90722071 100644 --- a/stdlib/LinearAlgebra/src/triangular.jl +++ b/stdlib/LinearAlgebra/src/triangular.jl @@ -478,8 +478,8 @@ function mul!(A::LowerTriangular, c::Number, B::UnitLowerTriangular) return A end -mul1!(A::Union{UpperTriangular,LowerTriangular}, c::Number) = mul!(A, A, c) -mul2!(c::Number, A::Union{UpperTriangular,LowerTriangular}) = mul!(A, c, A) +rmul!(A::Union{UpperTriangular,LowerTriangular}, c::Number) = mul!(A, A, c) +lmul!(c::Number, A::Union{UpperTriangular,LowerTriangular}) = mul!(A, c, A) fillstored!(A::LowerTriangular, x) = (fillband!(A.data, x, 1-size(A,1), 0); A) fillstored!(A::UnitLowerTriangular, x) = (fillband!(A.data, x, 1-size(A,1), -1); A) @@ -511,35 +511,35 @@ fillstored!(A::UnitUpperTriangular, x) = (fillband!(A.data, x, 1, size(A,2)-1); # BlasFloat routines # ###################### -mul2!(A::Tridiagonal, B::AbstractTriangular) = A*full!(B) # is this necessary? +lmul!(A::Tridiagonal, B::AbstractTriangular) = A*full!(B) # is this necessary? mul!(C::AbstractMatrix, A::AbstractTriangular, B::Tridiagonal) = mul!(C, copyto!(similar(parent(A)), A), B) mul!(C::AbstractMatrix, A::Tridiagonal, B::AbstractTriangular) = mul!(C, A, copyto!(similar(parent(B)), B)) mul!(C::AbstractVector, A::AbstractTriangular, transB::Transpose{<:Any,<:AbstractVecOrMat}) = - (B = transB.parent; mul2!(A, transpose!(C, B))) + (B = transB.parent; lmul!(A, transpose!(C, B))) mul!(C::AbstractMatrix, A::AbstractTriangular, transB::Transpose{<:Any,<:AbstractVecOrMat}) = - (B = transB.parent; mul2!(A, transpose!(C, B))) + (B = transB.parent; lmul!(A, transpose!(C, B))) mul!(C::AbstractMatrix, A::AbstractTriangular, adjB::Adjoint{<:Any,<:AbstractVecOrMat}) = - (B = adjB.parent; mul2!(A, adjoint!(C, B))) + (B = adjB.parent; lmul!(A, adjoint!(C, B))) mul!(C::AbstractVecOrMat, A::AbstractTriangular, adjB::Adjoint{<:Any,<:AbstractVecOrMat}) = - (B = adjB.parent; mul2!(A, adjoint!(C, B))) + (B = adjB.parent; lmul!(A, adjoint!(C, B))) # The three methods for each op are neceesary to avoid ambiguities with definitions in matmul.jl -mul!(C::AbstractVector , A::AbstractTriangular, B::AbstractVector) = mul2!(A, copyto!(C, B)) -mul!(C::AbstractMatrix , A::AbstractTriangular, B::AbstractVecOrMat) = mul2!(A, copyto!(C, B)) -mul!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = mul2!(A, copyto!(C, B)) +mul!(C::AbstractVector , A::AbstractTriangular, B::AbstractVector) = lmul!(A, copyto!(C, B)) +mul!(C::AbstractMatrix , A::AbstractTriangular, B::AbstractVecOrMat) = lmul!(A, copyto!(C, B)) +mul!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = lmul!(A, copyto!(C, B)) mul!(C::AbstractVector , adjA::Adjoint{<:Any,<:AbstractTriangular}, B::AbstractVector) = - (A = adjA.parent; mul2!(adjoint(A), copyto!(C, B))) + (A = adjA.parent; lmul!(adjoint(A), copyto!(C, B))) mul!(C::AbstractMatrix , adjA::Adjoint{<:Any,<:AbstractTriangular}, B::AbstractVecOrMat) = - (A = adjA.parent; mul2!(adjoint(A), copyto!(C, B))) + (A = adjA.parent; lmul!(adjoint(A), copyto!(C, B))) mul!(C::AbstractVecOrMat, adjA::Adjoint{<:Any,<:AbstractTriangular}, B::AbstractVecOrMat) = - (A = adjA.parent; mul2!(adjoint(A), copyto!(C, B))) + (A = adjA.parent; lmul!(adjoint(A), copyto!(C, B))) mul!(C::AbstractVector , transA::Transpose{<:Any,<:AbstractTriangular}, B::AbstractVector) = - (A = transA.parent; mul2!(transpose(A), copyto!(C, B))) + (A = transA.parent; lmul!(transpose(A), copyto!(C, B))) mul!(C::AbstractMatrix , transA::Transpose{<:Any,<:AbstractTriangular}, B::AbstractVecOrMat) = - (A = transA.parent; mul2!(transpose(A), copyto!(C, B))) + (A = transA.parent; lmul!(transpose(A), copyto!(C, B))) mul!(C::AbstractVecOrMat, transA::Transpose{<:Any,<:AbstractTriangular}, B::AbstractVecOrMat) = - (A = transA.parent; mul2!(transpose(A), copyto!(C, B))) + (A = transA.parent; lmul!(transpose(A), copyto!(C, B))) mul!(C::AbstractMatrix, A::Adjoint{<:Any,<:AbstractTriangular}, B::Adjoint{<:Any,<:AbstractVecOrMat}) = mul!(C, A, copy(B)) mul!(C::AbstractMatrix, A::Adjoint{<:Any,<:AbstractTriangular}, B::Transpose{<:Any,<:AbstractVecOrMat}) = mul!(C, A, copy(B)) mul!(C::AbstractMatrix, A::Transpose{<:Any,<:AbstractTriangular}, B::Adjoint{<:Any,<:AbstractVecOrMat}) = mul!(C, A, copy(B)) @@ -553,33 +553,33 @@ for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'), (:UnitUpperTriangular, 'U', 'U')) @eval begin # Vector multiplication - mul2!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} = + lmul!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} = BLAS.trmv!($uploc, 'N', $isunitc, A.data, b) - mul2!(transA::Transpose{<:Any,<:$t{T,<:StridedMatrix}}, b::StridedVector{T}) where {T<:BlasFloat} = + lmul!(transA::Transpose{<:Any,<:$t{T,<:StridedMatrix}}, b::StridedVector{T}) where {T<:BlasFloat} = (A = transA.parent; BLAS.trmv!($uploc, 'T', $isunitc, A.data, b)) - mul2!(adjA::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}, b::StridedVector{T}) where {T<:BlasReal} = + lmul!(adjA::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}, b::StridedVector{T}) where {T<:BlasReal} = (A = adjA.parent; BLAS.trmv!($uploc, 'T', $isunitc, A.data, b)) - mul2!(adjA::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}, b::StridedVector{T}) where {T<:BlasComplex} = + lmul!(adjA::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}, b::StridedVector{T}) where {T<:BlasComplex} = (A = adjA.parent; BLAS.trmv!($uploc, 'C', $isunitc, A.data, b)) # Matrix multiplication - mul2!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} = + lmul!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} = BLAS.trmm!('L', $uploc, 'N', $isunitc, one(T), A.data, B) - mul1!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} = + rmul!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} = BLAS.trmm!('R', $uploc, 'N', $isunitc, one(T), B.data, A) - mul2!(transA::Transpose{<:Any,<:$t{T,<:StridedMatrix}}, B::StridedMatrix{T}) where {T<:BlasFloat} = + lmul!(transA::Transpose{<:Any,<:$t{T,<:StridedMatrix}}, B::StridedMatrix{T}) where {T<:BlasFloat} = (A = transA.parent; BLAS.trmm!('L', $uploc, 'T', $isunitc, one(T), A.data, B)) - mul2!(adjA::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}, B::StridedMatrix{T}) where {T<:BlasComplex} = + lmul!(adjA::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}, B::StridedMatrix{T}) where {T<:BlasComplex} = (A = adjA.parent; BLAS.trmm!('L', $uploc, 'C', $isunitc, one(T), A.data, B)) - mul2!(adjA::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}, B::StridedMatrix{T}) where {T<:BlasReal} = + lmul!(adjA::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}, B::StridedMatrix{T}) where {T<:BlasReal} = (A = adjA.parent; BLAS.trmm!('L', $uploc, 'T', $isunitc, one(T), A.data, B)) - mul1!(A::StridedMatrix{T}, transB::Transpose{<:Any,<:$t{T,<:StridedMatrix}}) where {T<:BlasFloat} = + rmul!(A::StridedMatrix{T}, transB::Transpose{<:Any,<:$t{T,<:StridedMatrix}}) where {T<:BlasFloat} = (B = transB.parent; BLAS.trmm!('R', $uploc, 'T', $isunitc, one(T), B.data, A)) - mul1!(A::StridedMatrix{T}, adjB::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}) where {T<:BlasComplex} = + rmul!(A::StridedMatrix{T}, adjB::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}) where {T<:BlasComplex} = (B = adjB.parent; BLAS.trmm!('R', $uploc, 'C', $isunitc, one(T), B.data, A)) - mul1!(A::StridedMatrix{T}, adjB::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}) where {T<:BlasReal} = + rmul!(A::StridedMatrix{T}, adjB::Adjoint{<:Any,<:$t{T,<:StridedMatrix}}) where {T<:BlasReal} = (B = adjB.parent; BLAS.trmm!('R', $uploc, 'T', $isunitc, one(T), B.data, A)) # Left division @@ -715,7 +715,7 @@ for (t, unitt) in ((UpperTriangular, UnitUpperTriangular), end ## Generic triangular multiplication -function mul2!(A::UpperTriangular, B::StridedVecOrMat) +function lmul!(A::UpperTriangular, B::StridedVecOrMat) m, n = size(B, 1), size(B, 2) if m != size(A, 1) throw(DimensionMismatch("right hand side B needs first dimension of size $(size(A,1)), has size $m")) @@ -732,7 +732,7 @@ function mul2!(A::UpperTriangular, B::StridedVecOrMat) B end -function mul2!(A::UnitUpperTriangular, B::StridedVecOrMat) +function lmul!(A::UnitUpperTriangular, B::StridedVecOrMat) m, n = size(B, 1), size(B, 2) if m != size(A, 1) throw(DimensionMismatch("right hand side B needs first dimension of size $(size(A,1)), has size $m")) @@ -749,7 +749,7 @@ function mul2!(A::UnitUpperTriangular, B::StridedVecOrMat) B end -function mul2!(A::LowerTriangular, B::StridedVecOrMat) +function lmul!(A::LowerTriangular, B::StridedVecOrMat) m, n = size(B, 1), size(B, 2) if m != size(A, 1) throw(DimensionMismatch("right hand side B needs first dimension of size $(size(A,1)), has size $m")) @@ -765,7 +765,7 @@ function mul2!(A::LowerTriangular, B::StridedVecOrMat) end B end -function mul2!(A::UnitLowerTriangular, B::StridedVecOrMat) +function lmul!(A::UnitLowerTriangular, B::StridedVecOrMat) m, n = size(B, 1), size(B, 2) if m != size(A, 1) throw(DimensionMismatch("right hand side B needs first dimension of size $(size(A,1)), has size $m")) @@ -782,7 +782,7 @@ function mul2!(A::UnitLowerTriangular, B::StridedVecOrMat) B end -function mul2!(adjA::Adjoint{<:Any,<:UpperTriangular}, B::StridedVecOrMat) +function lmul!(adjA::Adjoint{<:Any,<:UpperTriangular}, B::StridedVecOrMat) A = adjA.parent m, n = size(B, 1), size(B, 2) if m != size(A, 1) @@ -800,7 +800,7 @@ function mul2!(adjA::Adjoint{<:Any,<:UpperTriangular}, B::StridedVecOrMat) B end -function mul2!(adjA::Adjoint{<:Any,<:UnitUpperTriangular}, B::StridedVecOrMat) +function lmul!(adjA::Adjoint{<:Any,<:UnitUpperTriangular}, B::StridedVecOrMat) A = adjA.parent m, n = size(B, 1), size(B, 2) if m != size(A, 1) @@ -818,7 +818,7 @@ function mul2!(adjA::Adjoint{<:Any,<:UnitUpperTriangular}, B::StridedVecOrMat) B end -function mul2!(adjA::Adjoint{<:Any,<:LowerTriangular}, B::StridedVecOrMat) +function lmul!(adjA::Adjoint{<:Any,<:LowerTriangular}, B::StridedVecOrMat) A = adjA.parent m, n = size(B, 1), size(B, 2) if m != size(A, 1) @@ -835,7 +835,7 @@ function mul2!(adjA::Adjoint{<:Any,<:LowerTriangular}, B::StridedVecOrMat) end B end -function mul2!(adjA::Adjoint{<:Any,<:UnitLowerTriangular}, B::StridedVecOrMat) +function lmul!(adjA::Adjoint{<:Any,<:UnitLowerTriangular}, B::StridedVecOrMat) A = adjA.parent m, n = size(B, 1), size(B, 2) if m != size(A, 1) @@ -853,7 +853,7 @@ function mul2!(adjA::Adjoint{<:Any,<:UnitLowerTriangular}, B::StridedVecOrMat) B end -function mul2!(transA::Transpose{<:Any,<:UpperTriangular}, B::StridedVecOrMat) +function lmul!(transA::Transpose{<:Any,<:UpperTriangular}, B::StridedVecOrMat) A = transA.parent m, n = size(B, 1), size(B, 2) if m != size(A, 1) @@ -870,7 +870,7 @@ function mul2!(transA::Transpose{<:Any,<:UpperTriangular}, B::StridedVecOrMat) end B end -function mul2!(transA::Transpose{<:Any,<:UnitUpperTriangular}, B::StridedVecOrMat) +function lmul!(transA::Transpose{<:Any,<:UnitUpperTriangular}, B::StridedVecOrMat) A = transA.parent m, n = size(B, 1), size(B, 2) if m != size(A, 1) @@ -888,7 +888,7 @@ function mul2!(transA::Transpose{<:Any,<:UnitUpperTriangular}, B::StridedVecOrMa B end -function mul2!(transA::Transpose{<:Any,<:LowerTriangular}, B::StridedVecOrMat) +function lmul!(transA::Transpose{<:Any,<:LowerTriangular}, B::StridedVecOrMat) A = transA.parent m, n = size(B, 1), size(B, 2) if m != size(A, 1) @@ -905,7 +905,7 @@ function mul2!(transA::Transpose{<:Any,<:LowerTriangular}, B::StridedVecOrMat) end B end -function mul2!(transA::Transpose{<:Any,<:UnitLowerTriangular}, B::StridedVecOrMat) +function lmul!(transA::Transpose{<:Any,<:UnitLowerTriangular}, B::StridedVecOrMat) A = transA.parent m, n = size(B, 1), size(B, 2) if m != size(A, 1) @@ -923,7 +923,7 @@ function mul2!(transA::Transpose{<:Any,<:UnitLowerTriangular}, B::StridedVecOrMa B end -function mul1!(A::StridedMatrix, B::UpperTriangular) +function rmul!(A::StridedMatrix, B::UpperTriangular) m, n = size(A) if size(B, 1) != n throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))")) @@ -939,7 +939,7 @@ function mul1!(A::StridedMatrix, B::UpperTriangular) end A end -function mul1!(A::StridedMatrix, B::UnitUpperTriangular) +function rmul!(A::StridedMatrix, B::UnitUpperTriangular) m, n = size(A) if size(B, 1) != n throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))")) @@ -956,7 +956,7 @@ function mul1!(A::StridedMatrix, B::UnitUpperTriangular) A end -function mul1!(A::StridedMatrix, B::LowerTriangular) +function rmul!(A::StridedMatrix, B::LowerTriangular) m, n = size(A) if size(B, 1) != n throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))")) @@ -972,7 +972,7 @@ function mul1!(A::StridedMatrix, B::LowerTriangular) end A end -function mul1!(A::StridedMatrix, B::UnitLowerTriangular) +function rmul!(A::StridedMatrix, B::UnitLowerTriangular) m, n = size(A) if size(B, 1) != n throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))")) @@ -989,7 +989,7 @@ function mul1!(A::StridedMatrix, B::UnitLowerTriangular) A end -function mul1!(A::StridedMatrix, adjB::Adjoint{<:Any,<:UpperTriangular}) +function rmul!(A::StridedMatrix, adjB::Adjoint{<:Any,<:UpperTriangular}) B = adjB.parent m, n = size(A) if size(B, 1) != n @@ -1007,7 +1007,7 @@ function mul1!(A::StridedMatrix, adjB::Adjoint{<:Any,<:UpperTriangular}) A end -function mul1!(A::StridedMatrix, adjB::Adjoint{<:Any,<:UnitUpperTriangular}) +function rmul!(A::StridedMatrix, adjB::Adjoint{<:Any,<:UnitUpperTriangular}) B = adjB.parent m, n = size(A) if size(B, 1) != n @@ -1025,7 +1025,7 @@ function mul1!(A::StridedMatrix, adjB::Adjoint{<:Any,<:UnitUpperTriangular}) A end -function mul1!(A::StridedMatrix, adjB::Adjoint{<:Any,<:LowerTriangular}) +function rmul!(A::StridedMatrix, adjB::Adjoint{<:Any,<:LowerTriangular}) B = adjB.parent m, n = size(A) if size(B, 1) != n @@ -1043,7 +1043,7 @@ function mul1!(A::StridedMatrix, adjB::Adjoint{<:Any,<:LowerTriangular}) A end -function mul1!(A::StridedMatrix, adjB::Adjoint{<:Any,<:UnitLowerTriangular}) +function rmul!(A::StridedMatrix, adjB::Adjoint{<:Any,<:UnitLowerTriangular}) B = adjB.parent m, n = size(A) if size(B, 1) != n @@ -1061,7 +1061,7 @@ function mul1!(A::StridedMatrix, adjB::Adjoint{<:Any,<:UnitLowerTriangular}) A end -function mul1!(A::StridedMatrix, transB::Transpose{<:Any,<:UpperTriangular}) +function rmul!(A::StridedMatrix, transB::Transpose{<:Any,<:UpperTriangular}) B = transB.parent m, n = size(A) if size(B, 1) != n @@ -1078,7 +1078,7 @@ function mul1!(A::StridedMatrix, transB::Transpose{<:Any,<:UpperTriangular}) end A end -function mul1!(A::StridedMatrix, transB::Transpose{<:Any,<:UnitUpperTriangular}) +function rmul!(A::StridedMatrix, transB::Transpose{<:Any,<:UnitUpperTriangular}) B = transB.parent m, n = size(A) if size(B, 1) != n @@ -1096,7 +1096,7 @@ function mul1!(A::StridedMatrix, transB::Transpose{<:Any,<:UnitUpperTriangular}) A end -function mul1!(A::StridedMatrix, transB::Transpose{<:Any,<:LowerTriangular}) +function rmul!(A::StridedMatrix, transB::Transpose{<:Any,<:LowerTriangular}) B = transB.parent m, n = size(A) if size(B, 1) != n @@ -1114,7 +1114,7 @@ function mul1!(A::StridedMatrix, transB::Transpose{<:Any,<:LowerTriangular}) A end -function mul1!(A::StridedMatrix, transB::Transpose{<:Any,<:UnitLowerTriangular}) +function rmul!(A::StridedMatrix, transB::Transpose{<:Any,<:UnitLowerTriangular}) B = transB.parent m, n = size(A) if size(B, 1) != n @@ -1542,14 +1542,14 @@ function rdiv!(A::StridedMatrix, transB::Transpose{<:Any,<:UnitLowerTriangular}) A end -mul2!(adjA::Adjoint{<:Any,<:Union{LowerTriangular,UnitLowerTriangular}}, B::UpperTriangular) = - (A = adjA.parent; UpperTriangular(mul2!(adjoint(A), triu!(B.data)))) -mul2!(adjA::Adjoint{<:Any,<:Union{UpperTriangular,UnitUpperTriangular}}, B::LowerTriangular) = - (A = adjA.parent; LowerTriangular(mul2!(adjoint(A), tril!(B.data)))) -mul2!(transA::Transpose{<:Any,<:Union{LowerTriangular,UnitLowerTriangular}}, B::UpperTriangular) = - (A = transA.parent; UpperTriangular(mul2!(transpose(A), triu!(B.data)))) -mul2!(transA::Transpose{<:Any,<:Union{UpperTriangular,UnitUpperTriangular}}, B::LowerTriangular) = - (A = transA.parent; LowerTriangular(mul2!(transpose(A), tril!(B.data)))) +lmul!(adjA::Adjoint{<:Any,<:Union{LowerTriangular,UnitLowerTriangular}}, B::UpperTriangular) = + (A = adjA.parent; UpperTriangular(lmul!(adjoint(A), triu!(B.data)))) +lmul!(adjA::Adjoint{<:Any,<:Union{UpperTriangular,UnitUpperTriangular}}, B::LowerTriangular) = + (A = adjA.parent; LowerTriangular(lmul!(adjoint(A), tril!(B.data)))) +lmul!(transA::Transpose{<:Any,<:Union{LowerTriangular,UnitLowerTriangular}}, B::UpperTriangular) = + (A = transA.parent; UpperTriangular(lmul!(transpose(A), triu!(B.data)))) +lmul!(transA::Transpose{<:Any,<:Union{UpperTriangular,UnitUpperTriangular}}, B::LowerTriangular) = + (A = transA.parent; LowerTriangular(lmul!(transpose(A), tril!(B.data)))) ldiv!(adjA::Adjoint{<:Any,<:Union{LowerTriangular,UnitLowerTriangular}}, B::UpperTriangular) = (A = adjA.parent; UpperTriangular(ldiv!(adjoint(A), triu!(B.data)))) ldiv!(adjA::Adjoint{<:Any,<:Union{UpperTriangular,UnitUpperTriangular}}, B::LowerTriangular) = @@ -1564,14 +1564,14 @@ rdiv!(A::UpperTriangular, B::Union{UpperTriangular,UnitUpperTriangular}) = rdiv!(A::LowerTriangular, B::Union{LowerTriangular,UnitLowerTriangular}) = LowerTriangular(rdiv!(tril!(A.data), B)) -mul1!(A::UpperTriangular, adjB::Adjoint{<:Any,<:Union{LowerTriangular,UnitLowerTriangular}}) = - (B = adjB.parent; UpperTriangular(mul1!(triu!(A.data), adjoint(B)))) -mul1!(A::LowerTriangular, adjB::Adjoint{<:Any,<:Union{UpperTriangular,UnitUpperTriangular}}) = - (B = adjB.parent; LowerTriangular(mul1!(tril!(A.data), adjoint(B)))) -mul1!(A::UpperTriangular, transB::Transpose{<:Any,<:Union{LowerTriangular,UnitLowerTriangular}}) = - (B = transB.parent; UpperTriangular(mul1!(triu!(A.data), transpose(B)))) -mul1!(A::LowerTriangular, transB::Transpose{<:Any,<:Union{UpperTriangular,UnitUpperTriangular}}) = - (B = transB.parent; LowerTriangular(mul1!(tril!(A.data), transpose(B)))) +rmul!(A::UpperTriangular, adjB::Adjoint{<:Any,<:Union{LowerTriangular,UnitLowerTriangular}}) = + (B = adjB.parent; UpperTriangular(rmul!(triu!(A.data), adjoint(B)))) +rmul!(A::LowerTriangular, adjB::Adjoint{<:Any,<:Union{UpperTriangular,UnitUpperTriangular}}) = + (B = adjB.parent; LowerTriangular(rmul!(tril!(A.data), adjoint(B)))) +rmul!(A::UpperTriangular, transB::Transpose{<:Any,<:Union{LowerTriangular,UnitLowerTriangular}}) = + (B = transB.parent; UpperTriangular(rmul!(triu!(A.data), transpose(B)))) +rmul!(A::LowerTriangular, transB::Transpose{<:Any,<:Union{UpperTriangular,UnitUpperTriangular}}) = + (B = transB.parent; LowerTriangular(rmul!(tril!(A.data), transpose(B)))) rdiv!(A::UpperTriangular, adjB::Adjoint{<:Any,<:Union{LowerTriangular,UnitLowerTriangular}}) = (B = adjB.parent; UpperTriangular(rdiv!(triu!(A.data), adjoint(B)))) rdiv!(A::LowerTriangular, adjB::Adjoint{<:Any,<:Union{UpperTriangular,UnitUpperTriangular}}) = @@ -1590,9 +1590,9 @@ rdiv!(A::LowerTriangular, transB::Transpose{<:Any,<:Union{UpperTriangular,UnitUp ## Some Triangular-Triangular cases. We might want to write taylored methods ## for these cases, but I'm not sure it is worth it. -(*)(A::Union{Tridiagonal,SymTridiagonal}, B::AbstractTriangular) = mul1!(Matrix(A), B) +(*)(A::Union{Tridiagonal,SymTridiagonal}, B::AbstractTriangular) = rmul!(Matrix(A), B) -for (f, f2!) in ((:*, :mul2!), (:\, :ldiv!)) +for (f, f2!) in ((:*, :lmul!), (:\, :ldiv!)) @eval begin function ($f)(A::LowerTriangular, B::LowerTriangular) TAB = typeof(($f)(zero(eltype(A)), zero(eltype(B))) + @@ -1629,8 +1629,8 @@ for (f, f2!) in ((:*, :mul2!), (:\, :ldiv!)) end for (ipop, op, xformtype, xformop) in ( - (:mul2!, :*, :Adjoint, :adjoint), - (:mul2!, :*, :Transpose, :transpose), + (:lmul!, :*, :Adjoint, :adjoint), + (:lmul!, :*, :Transpose, :transpose), (:ldiv!, :\, :Adjoint, :adjoint), (:ldiv!, :\, :Transpose, :transpose)) @eval begin @@ -1702,8 +1702,8 @@ function (/)(A::UpperTriangular, B::UnitUpperTriangular) end for (ipop, op, xformtype, xformop) in ( - (:mul1!, :*, :Adjoint, :adjoint), - (:mul1!, :*, :Transpose, :transpose), + (:rmul!, :*, :Adjoint, :adjoint), + (:rmul!, :*, :Transpose, :transpose), (:rdiv!, :/, :Adjoint, :adjoint), (:rdiv!, :/, :Transpose, :transpose)) @eval begin @@ -1750,21 +1750,21 @@ function *(A::AbstractTriangular, B::AbstractTriangular) TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) BB = similar(B, TAB, size(B)) copyto!(BB, B) - mul2!(convert(AbstractArray{TAB}, A), BB) + lmul!(convert(AbstractArray{TAB}, A), BB) end function *(adjA::Adjoint{<:Any,<:AbstractTriangular}, B::AbstractTriangular) A = adjA.parent TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) BB = similar(B, TAB, size(B)) copyto!(BB, B) - mul2!(adjoint(convert(AbstractArray{TAB}, A)), BB) + lmul!(adjoint(convert(AbstractArray{TAB}, A)), BB) end function *(transA::Transpose{<:Any,<:AbstractTriangular}, B::AbstractTriangular) A = transA.parent TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) BB = similar(B, TAB, size(B)) copyto!(BB, B) - mul2!(transpose(convert(AbstractArray{TAB}, A)), BB) + lmul!(transpose(convert(AbstractArray{TAB}, A)), BB) end function *(A::AbstractTriangular, adjB::Adjoint{<:Any,<:AbstractTriangular}) @@ -1772,14 +1772,14 @@ function *(A::AbstractTriangular, adjB::Adjoint{<:Any,<:AbstractTriangular}) TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) AA = similar(A, TAB, size(A)) copyto!(AA, A) - mul1!(AA, adjoint(convert(AbstractArray{TAB}, B))) + rmul!(AA, adjoint(convert(AbstractArray{TAB}, B))) end function *(A::AbstractTriangular, transB::Transpose{<:Any,<:AbstractTriangular}) B = transB.parent TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) AA = similar(A, TAB, size(A)) copyto!(AA, A) - mul1!(AA, transpose(convert(AbstractArray{TAB}, B))) + rmul!(AA, transpose(convert(AbstractArray{TAB}, B))) end for mat in (:AbstractVector, :AbstractMatrix) @@ -1789,21 +1789,21 @@ for mat in (:AbstractVector, :AbstractMatrix) TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) BB = similar(B, TAB, size(B)) copyto!(BB, B) - mul2!(convert(AbstractArray{TAB}, A), BB) + lmul!(convert(AbstractArray{TAB}, A), BB) end function *(adjA::Adjoint{<:Any,<:AbstractTriangular}, B::$mat) A = adjA.parent TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) BB = similar(B, TAB, size(B)) copyto!(BB, B) - mul2!(adjoint(convert(AbstractArray{TAB}, A)), BB) + lmul!(adjoint(convert(AbstractArray{TAB}, A)), BB) end function *(transA::Transpose{<:Any,<:AbstractTriangular}, B::$mat) A = transA.parent TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) BB = similar(B, TAB, size(B)) copyto!(BB, B) - mul2!(transpose(convert(AbstractArray{TAB}, A)), BB) + lmul!(transpose(convert(AbstractArray{TAB}, A)), BB) end end ### Left division with triangle to the left hence rhs cannot be transposed. No quotients. @@ -1905,21 +1905,21 @@ function *(A::AbstractMatrix, B::AbstractTriangular) TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) AA = similar(A, TAB, size(A)) copyto!(AA, A) - mul1!(AA, convert(AbstractArray{TAB}, B)) + rmul!(AA, convert(AbstractArray{TAB}, B)) end function *(A::AbstractMatrix, adjB::Adjoint{<:Any,<:AbstractTriangular}) B = adjB.parent TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) AA = similar(A, TAB, size(A)) copyto!(AA, A) - mul1!(AA, adjoint(convert(AbstractArray{TAB}, B))) + rmul!(AA, adjoint(convert(AbstractArray{TAB}, B))) end function *(A::AbstractMatrix, transB::Transpose{<:Any,<:AbstractTriangular}) B = transB.parent TAB = typeof(zero(eltype(A))*zero(eltype(B)) + zero(eltype(A))*zero(eltype(B))) AA = similar(A, TAB, size(A)) copyto!(AA, A) - mul1!(AA, transpose(convert(AbstractArray{TAB}, B))) + rmul!(AA, transpose(convert(AbstractArray{TAB}, B))) end # ambiguity resolution with definitions in linalg/rowvector.jl *(v::AdjointAbsVec, A::AbstractTriangular) = adjoint(adjoint(A) * v.parent) @@ -1956,7 +1956,7 @@ function powm!(A0::UpperTriangular{<:BlasFloat}, p::Real) end normA0 = norm(A0, 1) - mul1!(A0, 1/normA0) + rmul!(A0, 1/normA0) theta = [1.53e-5, 2.25e-3, 1.92e-2, 6.08e-2, 1.25e-1, 2.03e-1, 2.84e-1] n = checksquare(A0) @@ -2008,7 +2008,7 @@ function powm!(A0::UpperTriangular{<:BlasFloat}, p::Real) copyto!(S, Stmp) blockpower!(A0, S, p/(2^(s-m))) end - mul1!(S, normA0^p) + rmul!(S, normA0^p) return S end powm(A::LowerTriangular, p::Real) = copy(transpose(powm(copy(transpose(A)), p::Real))) @@ -2173,7 +2173,7 @@ function log(A0::UpperTriangular{T}) where T<:BlasFloat end # Scale back - mul2!(2^s, Y) + lmul!(2^s, Y) # Compute accurate diagonal and superdiagonal of log(T) for k = 1:n-1 diff --git a/stdlib/LinearAlgebra/src/uniformscaling.jl b/stdlib/LinearAlgebra/src/uniformscaling.jl index f2dbdfa3b74ba..a153882f1ed70 100644 --- a/stdlib/LinearAlgebra/src/uniformscaling.jl +++ b/stdlib/LinearAlgebra/src/uniformscaling.jl @@ -195,16 +195,16 @@ end *(J::UniformScaling, x::Number) = UniformScaling(J.λ*x) /(J1::UniformScaling, J2::UniformScaling) = J2.λ == 0 ? throw(SingularException(1)) : UniformScaling(J1.λ/J2.λ) -/(J::UniformScaling, A::AbstractMatrix) = mul2!(J.λ, inv(A)) +/(J::UniformScaling, A::AbstractMatrix) = lmul!(J.λ, inv(A)) /(A::AbstractMatrix, J::UniformScaling) = J.λ == 0 ? throw(SingularException(1)) : A/J.λ /(J::UniformScaling, x::Number) = UniformScaling(J.λ/x) \(J1::UniformScaling, J2::UniformScaling) = J1.λ == 0 ? throw(SingularException(1)) : UniformScaling(J1.λ\J2.λ) \(A::Union{Bidiagonal{T},AbstractTriangular{T}}, J::UniformScaling) where {T<:Number} = - mul1!(inv(A), J.λ) + rmul!(inv(A), J.λ) \(J::UniformScaling, A::AbstractVecOrMat) = J.λ == 0 ? throw(SingularException(1)) : J.λ\A -\(A::AbstractMatrix, J::UniformScaling) = mul1!(inv(A), J.λ) +\(A::AbstractMatrix, J::UniformScaling) = rmul!(inv(A), J.λ) \(x::Number, J::UniformScaling) = UniformScaling(x\J.λ) diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl index 8bc2d9403cdad..746596183ae89 100644 --- a/stdlib/LinearAlgebra/test/diagonal.jl +++ b/stdlib/LinearAlgebra/test/diagonal.jl @@ -3,7 +3,7 @@ module TestDiagonal using Test, LinearAlgebra, SparseArrays, Random -using LinearAlgebra: mul!, mul1!, mul2!, ldiv!, rdiv!, BlasFloat, BlasComplex, SingularException +using LinearAlgebra: mul!, rmul!, lmul!, ldiv!, rdiv!, BlasFloat, BlasComplex, SingularException n=12 #Size of matrix problem to test srand(1) @@ -105,7 +105,7 @@ srand(1) @test ldiv!(transpose(D), copy(U)) ≈ DM\U atol=atol_three @test ldiv!(adjoint(conj(D)), copy(U)) ≈ DM\U atol=atol_three Uc = copy(U') - target = mul1!(Uc, Diagonal(inv.(D.diag))) + target = rmul!(Uc, Diagonal(inv.(D.diag))) @test rdiv!(Uc, D) ≈ target atol=atol_three @test_throws DimensionMismatch rdiv!(Matrix{elty}(I, n-1, n-1), D) @test_throws SingularException rdiv!(Uc, Diagonal(fill!(similar(D.diag), 0))) @@ -147,9 +147,9 @@ srand(1) if relty <: BlasFloat b = rand(elty,n,n) b = sparse(b) - @test mul2!(copy(D), copy(b)) ≈ Array(D)*Array(b) - @test mul2!(transpose(copy(D)), copy(b)) ≈ transpose(Array(D))*Array(b) - @test mul2!(adjoint(copy(D)), copy(b)) ≈ Array(D)'*Array(b) + @test lmul!(copy(D), copy(b)) ≈ Array(D)*Array(b) + @test lmul!(transpose(copy(D)), copy(b)) ≈ transpose(Array(D))*Array(b) + @test lmul!(adjoint(copy(D)), copy(b)) ≈ Array(D)'*Array(b) end end @@ -178,13 +178,13 @@ srand(1) VV = Array(D) DD = copy(D) r = VV * Matrix(D) - @test Array(mul1!(VV, DD)) ≈ r ≈ Array(D)*Array(D) + @test Array(rmul!(VV, DD)) ≈ r ≈ Array(D)*Array(D) DD = copy(D) r = VV * transpose(Array(D)) - @test Array(mul1!(VV, transpose(DD))) ≈ r + @test Array(rmul!(VV, transpose(DD))) ≈ r DD = copy(D) r = VV * Array(D)' - @test Array(mul1!(VV, adjoint(DD))) ≈ r + @test Array(rmul!(VV, adjoint(DD))) ≈ r end @testset "triu/tril" begin @test istriu(D) @@ -348,12 +348,12 @@ end end let D1 = Diagonal(rand(5)), D2 = Diagonal(rand(5)) - @test LinearAlgebra.mul1!(copy(D1),D2) == D1*D2 - @test LinearAlgebra.mul2!(D1,copy(D2)) == D1*D2 - @test LinearAlgebra.mul1!(copy(D1),transpose(D2)) == D1*transpose(D2) - @test LinearAlgebra.mul2!(transpose(D1),copy(D2)) == transpose(D1)*D2 - @test LinearAlgebra.mul1!(copy(D1),adjoint(D2)) == D1*adjoint(D2) - @test LinearAlgebra.mul2!(adjoint(D1),copy(D2)) == adjoint(D1)*D2 + @test LinearAlgebra.rmul!(copy(D1),D2) == D1*D2 + @test LinearAlgebra.lmul!(D1,copy(D2)) == D1*D2 + @test LinearAlgebra.rmul!(copy(D1),transpose(D2)) == D1*transpose(D2) + @test LinearAlgebra.lmul!(transpose(D1),copy(D2)) == transpose(D1)*D2 + @test LinearAlgebra.rmul!(copy(D1),adjoint(D2)) == D1*adjoint(D2) + @test LinearAlgebra.lmul!(adjoint(D1),copy(D2)) == adjoint(D1)*D2 end @testset "multiplication of QR Q-factor and Diagonal (#16615 spot test)" begin @@ -361,7 +361,7 @@ end Q = qrfact(randn(5, 5)).Q @test D * Q' == Array(D) * Q' Q = qrfact(randn(5, 5), Val(true)).Q - @test_throws ArgumentError mul2!(Q, D) + @test_throws ArgumentError lmul!(Q, D) end @testset "block diagonal matrices" begin diff --git a/stdlib/LinearAlgebra/test/generic.jl b/stdlib/LinearAlgebra/test/generic.jl index d961181547290..081f563e3a648 100644 --- a/stdlib/LinearAlgebra/test/generic.jl +++ b/stdlib/LinearAlgebra/test/generic.jl @@ -182,19 +182,19 @@ end aa = reshape([1.:6;], (2,3)) for a in (aa, view(aa, 1:2, 1:2)) am, an = size(a) - @testset "Scaling with mul1! and mul2" begin - @test mul1!(copy(a), 5.) == a*5 - @test mul2!(5., copy(a)) == a*5 + @testset "Scaling with rmul! and lmul" begin + @test rmul!(copy(a), 5.) == a*5 + @test lmul!(5., copy(a)) == a*5 b = randn(LinearAlgebra.SCAL_CUTOFF) # make sure we try BLAS path subB = view(b, :, :) - @test mul1!(copy(b), 5.) == b*5 - @test mul1!(copy(subB), 5.) == subB*5 - @test mul2!(Diagonal([1.; 2.]), copy(a)) == a.*[1; 2] - @test mul2!(Diagonal([1; 2]), copy(a)) == a.*[1; 2] - @test mul1!(copy(a), Diagonal(1.:an)) == a.*Vector(1:an)' - @test mul1!(copy(a), Diagonal(1:an)) == a.*Vector(1:an)' - @test_throws DimensionMismatch mul2!(Diagonal(Vector{Float64}(uninitialized,am+1)), a) - @test_throws DimensionMismatch mul1!(a, Diagonal(Vector{Float64}(uninitialized,an+1))) + @test rmul!(copy(b), 5.) == b*5 + @test rmul!(copy(subB), 5.) == subB*5 + @test lmul!(Diagonal([1.; 2.]), copy(a)) == a.*[1; 2] + @test lmul!(Diagonal([1; 2]), copy(a)) == a.*[1; 2] + @test rmul!(copy(a), Diagonal(1.:an)) == a.*Vector(1:an)' + @test rmul!(copy(a), Diagonal(1:an)) == a.*Vector(1:an)' + @test_throws DimensionMismatch lmul!(Diagonal(Vector{Float64}(uninitialized,am+1)), a) + @test_throws DimensionMismatch rmul!(a, Diagonal(Vector{Float64}(uninitialized,an+1))) end @testset "Scaling with 3-argument mul!" begin @@ -212,7 +212,7 @@ end end @testset "scale real matrix by complex type" begin - @test_throws InexactError mul1!([1.0], 2.0im) + @test_throws InexactError rmul!([1.0], 2.0im) @test isequal([1.0] * 2.0im, Complex{Float64}[2.0im]) @test isequal(2.0im * [1.0], Complex{Float64}[2.0im]) @test isequal(Float32[1.0] * 2.0f0im, Complex{Float32}[2.0im]) @@ -226,7 +226,7 @@ end @testset "* and mul! for non-commutative scaling" begin q = Quaternion(0.44567, 0.755871, 0.882548, 0.423612) qmat = [Quaternion(0.015007, 0.355067, 0.418645, 0.318373)] - @test mul2!(q, copy(qmat)) != mul1!(copy(qmat), q) + @test lmul!(q, copy(qmat)) != rmul!(copy(qmat), q) @test q*qmat ≉ qmat*q @test conj(q*qmat) ≈ conj(qmat)*conj(q) @test q * (q \ qmat) ≈ qmat ≈ (qmat / q) * q diff --git a/stdlib/LinearAlgebra/test/givens.jl b/stdlib/LinearAlgebra/test/givens.jl index df15b0a088926..752b0aac0ab29 100644 --- a/stdlib/LinearAlgebra/test/givens.jl +++ b/stdlib/LinearAlgebra/test/givens.jl @@ -3,7 +3,7 @@ module TestGivens using Test, LinearAlgebra, Random -using LinearAlgebra: mul1!, mul2! +using LinearAlgebra: rmul!, lmul! # Test givens rotations @testset for elty in (Float32, Float64, ComplexF32, ComplexF64) @@ -18,11 +18,11 @@ using LinearAlgebra: mul1!, mul2! for j = 1:8 for i = j+2:10 G, _ = givens(A, j+1, i, j) - mul2!(G, A) - mul1!(A, adjoint(G)) - mul2!(G, R) + lmul!(G, A) + rmul!(A, adjoint(G)) + lmul!(G, R) - @test mul2!(G,Matrix{elty}(I, 10, 10)) == [G[i,j] for i=1:10,j=1:10] + @test lmul!(G,Matrix{elty}(I, 10, 10)) == [G[i,j] for i=1:10,j=1:10] @testset "transposes" begin @test copy(G')*G*Matrix(elty(1)I, 10, 10) ≈ Matrix(I, 10, 10) @@ -35,8 +35,8 @@ using LinearAlgebra: mul1!, mul2! @test_throws ArgumentError givens(A, 3, 3, 2) @test_throws ArgumentError givens(one(elty),zero(elty),2,2) G, _ = givens(one(elty),zero(elty),11,12) - @test_throws DimensionMismatch mul2!(G, A) - @test_throws DimensionMismatch mul1!(A, adjoint(G)) + @test_throws DimensionMismatch lmul!(G, A) + @test_throws DimensionMismatch rmul!(A, adjoint(G)) @test abs.(A) ≈ abs.(hessfact(Ac).H) @test norm(R*Matrix{elty}(I, 10, 10)) ≈ one(elty) diff --git a/stdlib/LinearAlgebra/test/lq.jl b/stdlib/LinearAlgebra/test/lq.jl index 8b51b496f09f9..9d6bb406e0964 100644 --- a/stdlib/LinearAlgebra/test/lq.jl +++ b/stdlib/LinearAlgebra/test/lq.jl @@ -3,7 +3,7 @@ module TestLQ using Test, LinearAlgebra, Random -using LinearAlgebra: BlasComplex, BlasFloat, BlasReal, mul1!, mul2! +using LinearAlgebra: BlasComplex, BlasFloat, BlasReal, rmul!, lmul! n = 10 @@ -21,7 +21,7 @@ breal = randn(n,2)/2 bimg = randn(n,2)/2 # helper functions to unambiguously recover explicit forms of an LQPackedQ -squareQ(Q::LinearAlgebra.LQPackedQ) = (n = size(Q.factors, 2); mul2!(Q, Matrix{eltype(Q)}(I, n, n))) +squareQ(Q::LinearAlgebra.LQPackedQ) = (n = size(Q.factors, 2); lmul!(Q, Matrix{eltype(Q)}(I, n, n))) rectangularQ(Q::LinearAlgebra.LQPackedQ) = convert(Array, Q) @testset for eltya in (Float32, Float64, ComplexF32, ComplexF64) @@ -97,9 +97,9 @@ rectangularQ(Q::LinearAlgebra.LQPackedQ) = convert(Array, Q) l,q = lqa.L, lqa.Q @test rectangularQ(q)*rectangularQ(q)' ≈ Matrix(I, n1, n1) @test squareQ(q)'*squareQ(q) ≈ Matrix(I, n1, n1) - @test_throws DimensionMismatch mul1!(Matrix{eltya}(I, n+1, n+1),q) - @test mul2!(adjoint(q), rectangularQ(q)) ≈ Matrix(I, n1, n1) - @test_throws DimensionMismatch mul1!(Matrix{eltya}(I, n+1, n+1), adjoint(q)) + @test_throws DimensionMismatch rmul!(Matrix{eltya}(I, n+1, n+1),q) + @test lmul!(adjoint(q), rectangularQ(q)) ≈ Matrix(I, n1, n1) + @test_throws DimensionMismatch rmul!(Matrix{eltya}(I, n+1, n+1), adjoint(q)) @test_throws BoundsError size(q,-1) end end @@ -147,7 +147,7 @@ end function getqs(F::LinearAlgebra.LQ) implicitQ = F.Q sq = size(implicitQ.factors, 2) - explicitQ = mul2!(implicitQ, Matrix{eltype(implicitQ)}(I, sq, sq)) + explicitQ = lmul!(implicitQ, Matrix{eltype(implicitQ)}(I, sq, sq)) return implicitQ, explicitQ end @@ -188,7 +188,7 @@ end @testset "postmultiplication with / right-application of LQPackedQ (#23779)" begin function getqs(F::LinearAlgebra.LQ) implicitQ = F.Q - explicitQ = mul2!(implicitQ, Matrix{eltype(implicitQ)}(I, size(implicitQ)...)) + explicitQ = lmul!(implicitQ, Matrix{eltype(implicitQ)}(I, size(implicitQ)...)) return implicitQ, explicitQ end # for any shape m-by-n of LQ-factored matrix, where Q is an LQPackedQ diff --git a/stdlib/LinearAlgebra/test/qr.jl b/stdlib/LinearAlgebra/test/qr.jl index 99385030b556d..e6270c082c2a1 100644 --- a/stdlib/LinearAlgebra/test/qr.jl +++ b/stdlib/LinearAlgebra/test/qr.jl @@ -3,7 +3,7 @@ module TestQR using Test, LinearAlgebra, Random -using LinearAlgebra: BlasComplex, BlasFloat, BlasReal, QRPivoted, mul1!, mul2! +using LinearAlgebra: BlasComplex, BlasFloat, BlasReal, QRPivoted, rmul!, lmul! n = 10 @@ -21,7 +21,7 @@ breal = randn(n,2)/2 bimg = randn(n,2)/2 # helper functions to unambiguously recover explicit forms of an implicit QR Q -squareQ(Q::LinearAlgebra.AbstractQ) = (sq = size(Q.factors, 1); mul2!(Q, Matrix{eltype(Q)}(I, sq, sq))) +squareQ(Q::LinearAlgebra.AbstractQ) = (sq = size(Q.factors, 1); lmul!(Q, Matrix{eltype(Q)}(I, sq, sq))) rectangularQ(Q::LinearAlgebra.AbstractQ) = convert(Array, Q) @testset for eltya in (Float32, Float64, ComplexF32, ComplexF64, BigFloat, Int) @@ -136,20 +136,20 @@ rectangularQ(Q::LinearAlgebra.AbstractQ) = convert(Array, Q) a = raw_a qrpa = factorize(a[:,1:n1]) q, r = qrpa.Q, qrpa.R - @test mul1!(copy(squareQ(q)'), q) ≈ Matrix(I, n, n) - @test_throws DimensionMismatch mul1!(Matrix{eltya}(I, n+1, n+1),q) - @test mul1!(squareQ(q), adjoint(q)) ≈ Matrix(I, n, n) - @test_throws DimensionMismatch mul1!(Matrix{eltya}(I, n+1, n+1), adjoint(q)) + @test rmul!(copy(squareQ(q)'), q) ≈ Matrix(I, n, n) + @test_throws DimensionMismatch rmul!(Matrix{eltya}(I, n+1, n+1),q) + @test rmul!(squareQ(q), adjoint(q)) ≈ Matrix(I, n, n) + @test_throws DimensionMismatch rmul!(Matrix{eltya}(I, n+1, n+1), adjoint(q)) @test_throws BoundsError size(q,-1) - @test_throws DimensionMismatch LinearAlgebra.mul2!(q,zeros(eltya,n1+1)) - @test_throws DimensionMismatch LinearAlgebra.mul2!(adjoint(q), zeros(eltya,n1+1)) + @test_throws DimensionMismatch LinearAlgebra.lmul!(q,zeros(eltya,n1+1)) + @test_throws DimensionMismatch LinearAlgebra.lmul!(adjoint(q), zeros(eltya,n1+1)) qra = qrfact(a[:,1:n1], Val(false)) q, r = qra.Q, qra.R - @test mul1!(copy(squareQ(q)'), q) ≈ Matrix(I, n, n) - @test_throws DimensionMismatch mul1!(Matrix{eltya}(I, n+1, n+1),q) - @test mul1!(squareQ(q), adjoint(q)) ≈ Matrix(I, n, n) - @test_throws DimensionMismatch mul1!(Matrix{eltya}(I, n+1, n+1),adjoint(q)) + @test rmul!(copy(squareQ(q)'), q) ≈ Matrix(I, n, n) + @test_throws DimensionMismatch rmul!(Matrix{eltya}(I, n+1, n+1),q) + @test rmul!(squareQ(q), adjoint(q)) ≈ Matrix(I, n, n) + @test_throws DimensionMismatch rmul!(Matrix{eltya}(I, n+1, n+1),adjoint(q)) @test_throws BoundsError size(q,-1) @test_throws DimensionMismatch q * Matrix{Int8}(I, n+4, n+4) end diff --git a/stdlib/LinearAlgebra/test/special.jl b/stdlib/LinearAlgebra/test/special.jl index 9563ce13507ca..e63929d9497f1 100644 --- a/stdlib/LinearAlgebra/test/special.jl +++ b/stdlib/LinearAlgebra/test/special.jl @@ -3,7 +3,7 @@ module TestSpecial using Test, LinearAlgebra, SparseArrays, Random -using LinearAlgebra: mul1! +using LinearAlgebra: rmul! n= 10 #Size of matrix to test srand(1) @@ -118,10 +118,10 @@ end b = rand(n,n) qrb = qrfact(b,Val(true)) @test *(atri, adjoint(qrb.Q)) ≈ Matrix(atri) * qrb.Q' - @test mul1!(copy(atri), adjoint(qrb.Q)) ≈ Matrix(atri) * qrb.Q' + @test rmul!(copy(atri), adjoint(qrb.Q)) ≈ Matrix(atri) * qrb.Q' qrb = qrfact(b,Val(false)) @test *(atri, adjoint(qrb.Q)) ≈ Matrix(atri) * qrb.Q' - @test mul1!(copy(atri), adjoint(qrb.Q)) ≈ Matrix(atri) * qrb.Q' + @test rmul!(copy(atri), adjoint(qrb.Q)) ≈ Matrix(atri) * qrb.Q' end end diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl index ecab52d5b5390..284938e1fcd9d 100644 --- a/stdlib/LinearAlgebra/test/triangular.jl +++ b/stdlib/LinearAlgebra/test/triangular.jl @@ -6,7 +6,7 @@ debug = false using Test, LinearAlgebra, SparseArrays, Random using LinearAlgebra: BlasFloat, errorbounds, full!, naivesub!, transpose!, UnitUpperTriangular, UnitLowerTriangular, - mul!, rdiv!, mul1!, mul2! + mul!, rdiv!, rmul!, lmul! debug && println("Triangular matrices") @@ -195,10 +195,10 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo ci = cr * im if elty1 <: Real A1tmp = copy(A1) - mul1!(A1tmp, cr) + rmul!(A1tmp, cr) @test A1tmp == cr*A1 A1tmp = copy(A1) - mul2!(cr, A1tmp) + lmul!(cr, A1tmp) @test A1tmp == cr*A1 A1tmp = copy(A1) A2tmp = unitt(A1) @@ -206,10 +206,10 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo @test A1tmp == cr * A2tmp else A1tmp = copy(A1) - mul1!(A1tmp, ci) + rmul!(A1tmp, ci) @test A1tmp == ci*A1 A1tmp = copy(A1) - mul2!(ci, A1tmp) + lmul!(ci, A1tmp) @test A1tmp == ci*A1 A1tmp = copy(A1) A2tmp = unitt(A1) @@ -322,7 +322,7 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo if !(eltyB in (BigFloat, Complex{BigFloat})) # rand does not support BigFloat and Complex{BigFloat} as of Dec 2015 Tri = Tridiagonal(rand(eltyB,n-1),rand(eltyB,n),rand(eltyB,n-1)) - @test mul2!(Tri,copy(A1)) ≈ Tri*Matrix(A1) + @test lmul!(Tri,copy(A1)) ≈ Tri*Matrix(A1) end # Triangular-dense Matrix/vector multiplication @@ -360,12 +360,12 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo end #error handling Ann, Bmm, bm = A1, Matrix{eltyB}(uninitialized, n+1, n+1), Vector{eltyB}(uninitialized, n+1) - @test_throws DimensionMismatch mul2!(Ann, bm) - @test_throws DimensionMismatch mul1!(Bmm, Ann) - @test_throws DimensionMismatch mul2!(transpose(Ann), bm) - @test_throws DimensionMismatch mul2!(adjoint(Ann), bm) - @test_throws DimensionMismatch mul1!(Bmm, adjoint(Ann)) - @test_throws DimensionMismatch mul1!(Bmm, transpose(Ann)) + @test_throws DimensionMismatch lmul!(Ann, bm) + @test_throws DimensionMismatch rmul!(Bmm, Ann) + @test_throws DimensionMismatch lmul!(transpose(Ann), bm) + @test_throws DimensionMismatch lmul!(adjoint(Ann), bm) + @test_throws DimensionMismatch rmul!(Bmm, adjoint(Ann)) + @test_throws DimensionMismatch rmul!(Bmm, transpose(Ann)) # ... and division @test A1\B[:,1] ≈ Matrix(A1)\B[:,1] diff --git a/stdlib/SparseArrays/src/SparseArrays.jl b/stdlib/SparseArrays/src/SparseArrays.jl index 714a4ee6c8af8..7cc27133c825f 100644 --- a/stdlib/SparseArrays/src/SparseArrays.jl +++ b/stdlib/SparseArrays/src/SparseArrays.jl @@ -14,7 +14,7 @@ using LinearAlgebra import Base: +, -, *, \, /, &, |, xor, == import LinearAlgebra: mul!, ldiv!, rdiv!, chol, adjoint!, diag, diff, dot, eig, issymmetric, istril, istriu, lu, trace, transpose!, tril!, triu!, - vecnorm, cond, diagm, factorize, ishermitian, norm, mul1!, mul2!, tril, triu + vecnorm, cond, diagm, factorize, ishermitian, norm, lmul!, rmul!, tril, triu import Base: @get!, acos, acosd, acot, acotd, acsch, asech, asin, asind, asinh, atan, atand, atanh, broadcast!, conj!, cos, cosc, cosd, cosh, cospi, cot, diff --git a/stdlib/SparseArrays/src/linalg.jl b/stdlib/SparseArrays/src/linalg.jl index fc7e052913774..d9aa4238df152 100644 --- a/stdlib/SparseArrays/src/linalg.jl +++ b/stdlib/SparseArrays/src/linalg.jl @@ -36,7 +36,7 @@ function mul!(α::Number, A::SparseMatrixCSC, B::StridedVecOrMat, β::Number, C: nzv = A.nzval rv = A.rowval if β != 1 - β != 0 ? mul1!(C, β) : fill!(C, zero(eltype(C))) + β != 0 ? rmul!(C, β) : fill!(C, zero(eltype(C))) end for k = 1:size(C, 2) for col = 1:A.n @@ -61,7 +61,7 @@ function mul!(α::Number, adjA::Adjoint{<:Any,<:SparseMatrixCSC}, B::StridedVecO nzv = A.nzval rv = A.rowval if β != 1 - β != 0 ? mul1!(C, β) : fill!(C, zero(eltype(C))) + β != 0 ? rmul!(C, β) : fill!(C, zero(eltype(C))) end for k = 1:size(C, 2) for col = 1:A.n @@ -87,7 +87,7 @@ function mul!(α::Number, transA::Transpose{<:Any,<:SparseMatrixCSC}, B::Strided nzv = A.nzval rv = A.rowval if β != 1 - β != 0 ? mul1!(C, β) : fill!(C, zero(eltype(C))) + β != 0 ? rmul!(C, β) : fill!(C, zero(eltype(C))) end for k = 1:size(C, 2) for col = 1:A.n @@ -628,7 +628,7 @@ function normestinv(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A)))) end end end - mul1!(X, inv(n)) + rmul!(X, inv(n)) iter = 0 local est @@ -913,12 +913,12 @@ function mul!(C::SparseMatrixCSC, b::Number, A::SparseMatrixCSC) C end -function mul1!(A::SparseMatrixCSC, b::Number) - mul1!(A.nzval, b) +function rmul!(A::SparseMatrixCSC, b::Number) + rmul!(A.nzval, b) return A end -function mul2!(b::Number, A::SparseMatrixCSC) - mul2!(b, A.nzval) +function lmul!(b::Number, A::SparseMatrixCSC) + lmul!(b, A.nzval) return A end @@ -1032,5 +1032,5 @@ function Base.cov(X::SparseMatrixCSC, vardim::Int=1; corrected::Bool=true) end # scale with the sample size n or the corrected sample size n - 1 - return mul1!(out, inv(n - corrected)) + return rmul!(out, inv(n - corrected)) end diff --git a/stdlib/SparseArrays/src/sparsevector.jl b/stdlib/SparseArrays/src/sparsevector.jl index bd4a7dfef2fea..fae9d203cb770 100644 --- a/stdlib/SparseArrays/src/sparsevector.jl +++ b/stdlib/SparseArrays/src/sparsevector.jl @@ -1472,20 +1472,20 @@ end # scaling -function mul1!(x::SparseVectorUnion, a::Real) - mul1!(nonzeros(x), a) +function rmul!(x::SparseVectorUnion, a::Real) + rmul!(nonzeros(x), a) return x end -function mul1!(x::SparseVectorUnion, a::Complex) - mul1!(nonzeros(x), a) +function rmul!(x::SparseVectorUnion, a::Complex) + rmul!(nonzeros(x), a) return x end -function mul2!(a::Real, x::SparseVectorUnion) - mul1!(nonzeros(x), a) +function lmul!(a::Real, x::SparseVectorUnion) + rmul!(nonzeros(x), a) return x end -function mul2!(a::Complex, x::SparseVectorUnion) - mul1!(nonzeros(x), a) +function lmul!(a::Complex, x::SparseVectorUnion) + rmul!(nonzeros(x), a) return x end @@ -1588,7 +1588,7 @@ function mul!(α::Number, A::StridedMatrix, x::AbstractSparseVector, β::Number, length(x) == n && length(y) == m || throw(DimensionMismatch()) m == 0 && return y if β != one(β) - β == zero(β) ? fill!(y, zero(eltype(y))) : mul1!(y, β) + β == zero(β) ? fill!(y, zero(eltype(y))) : rmul!(y, β) end α == zero(α) && return y @@ -1627,7 +1627,7 @@ function mul!(α::Number, transA::Transpose{<:Any,<:StridedMatrix}, x::AbstractS length(x) == m && length(y) == n || throw(DimensionMismatch()) n == 0 && return y if β != one(β) - β == zero(β) ? fill!(y, zero(eltype(y))) : mul1!(y, β) + β == zero(β) ? fill!(y, zero(eltype(y))) : rmul!(y, β) end α == zero(α) && return y @@ -1685,7 +1685,7 @@ function mul!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Numbe length(x) == n && length(y) == m || throw(DimensionMismatch()) m == 0 && return y if β != one(β) - β == zero(β) ? fill!(y, zero(eltype(y))) : mul1!(y, β) + β == zero(β) ? fill!(y, zero(eltype(y))) : rmul!(y, β) end α == zero(α) && return y @@ -1729,7 +1729,7 @@ function _At_or_Ac_mul_B!(tfun::Function, length(x) == m && length(y) == n || throw(DimensionMismatch()) n == 0 && return y if β != one(β) - β == zero(β) ? fill!(y, zero(eltype(y))) : mul1!(y, β) + β == zero(β) ? fill!(y, zero(eltype(y))) : rmul!(y, β) end α == zero(α) && return y diff --git a/stdlib/SparseArrays/test/sparse.jl b/stdlib/SparseArrays/test/sparse.jl index 1008ff604d8a7..8db68a6d9c0c0 100644 --- a/stdlib/SparseArrays/test/sparse.jl +++ b/stdlib/SparseArrays/test/sparse.jl @@ -326,31 +326,31 @@ sA = sprandn(3, 7, 0.5) sC = similar(sA) dA = Array(sA) -@testset "scaling with * and mul!, mul1!, and mul2!" begin +@testset "scaling with * and mul!, rmul!, and lmul!" begin b = randn(7) @test dA * Diagonal(b) == sA * Diagonal(b) @test dA * Diagonal(b) == mul!(sC, sA, Diagonal(b)) - @test dA * Diagonal(b) == mul1!(copy(sA), Diagonal(b)) + @test dA * Diagonal(b) == rmul!(copy(sA), Diagonal(b)) b = randn(3) @test Diagonal(b) * dA == Diagonal(b) * sA @test Diagonal(b) * dA == mul!(sC, Diagonal(b), sA) - @test Diagonal(b) * dA == mul2!(Diagonal(b), copy(sA)) + @test Diagonal(b) * dA == lmul!(Diagonal(b), copy(sA)) @test dA * 0.5 == sA * 0.5 @test dA * 0.5 == mul!(sC, sA, 0.5) - @test dA * 0.5 == mul1!(copy(sA), 0.5) + @test dA * 0.5 == rmul!(copy(sA), 0.5) @test 0.5 * dA == 0.5 * sA @test 0.5 * dA == mul!(sC, sA, 0.5) - @test 0.5 * dA == mul2!(0.5, copy(sA)) + @test 0.5 * dA == lmul!(0.5, copy(sA)) @test mul!(sC, 0.5, sA) == mul!(sC, sA, 0.5) @testset "inverse scaling with mul!" begin bi = inv.(b) dAt = copy(transpose(dA)) sAt = copy(transpose(sA)) - @test mul1!(copy(dAt), Diagonal(bi)) ≈ rdiv!(copy(sAt), Diagonal(b)) - @test mul1!(copy(dAt), Diagonal(bi)) ≈ rdiv!(copy(sAt), transpose(Diagonal(b))) - @test mul1!(copy(dAt), Diagonal(conj(bi))) ≈ rdiv!(copy(sAt), adjoint(Diagonal(b))) + @test rmul!(copy(dAt), Diagonal(bi)) ≈ rdiv!(copy(sAt), Diagonal(b)) + @test rmul!(copy(dAt), Diagonal(bi)) ≈ rdiv!(copy(sAt), transpose(Diagonal(b))) + @test rmul!(copy(dAt), Diagonal(conj(bi))) ≈ rdiv!(copy(sAt), adjoint(Diagonal(b))) @test_throws DimensionMismatch rdiv!(copy(sAt), Diagonal(fill(1., length(b)+1))) @test_throws LinearAlgebra.SingularException rdiv!(copy(sAt), Diagonal(zeros(length(b)))) end diff --git a/stdlib/SparseArrays/test/sparsevector.jl b/stdlib/SparseArrays/test/sparsevector.jl index 5d5940c08ef11..0604470cf4ee8 100644 --- a/stdlib/SparseArrays/test/sparsevector.jl +++ b/stdlib/SparseArrays/test/sparsevector.jl @@ -782,16 +782,16 @@ end @test exact_equal(x / α, SparseVector(x.n, x.nzind, x.nzval / α)) xc = copy(x) - @test mul1!(xc, α) === xc + @test rmul!(xc, α) === xc @test exact_equal(xc, sx) xc = copy(x) - @test mul2!(α, xc) === xc + @test lmul!(α, xc) === xc @test exact_equal(xc, sx) xc = copy(x) - @test mul1!(xc, complex(α, 0.0)) === xc + @test rmul!(xc, complex(α, 0.0)) === xc @test exact_equal(xc, sx) xc = copy(x) - @test mul2!(complex(α, 0.0), xc) === xc + @test lmul!(complex(α, 0.0), xc) === xc @test exact_equal(xc, sx) end @@ -1258,7 +1258,7 @@ end Aj, Ajview = A[:, j], view(A, :, j) @test norm(Aj) == norm(Ajview) @test dot(Aj, copy(Aj)) == dot(Ajview, Aj) # don't alias since it takes a different code path - @test mul1!(Aj, 0.1) == mul1!(Ajview, 0.1) + @test rmul!(Aj, 0.1) == rmul!(Ajview, 0.1) @test Aj*0.1 == Ajview*0.1 @test 0.1*Aj == 0.1*Ajview @test Aj/0.1 == Ajview/0.1 diff --git a/stdlib/SuiteSparse/src/spqr.jl b/stdlib/SuiteSparse/src/spqr.jl index 4245c264d8da6..1686a5bc84381 100644 --- a/stdlib/SuiteSparse/src/spqr.jl +++ b/stdlib/SuiteSparse/src/spqr.jl @@ -198,7 +198,7 @@ LinearAlgebra.qrfact(A::SparseMatrixCSC; tol = _default_tol(A)) = qrfact(A, Val{ LinearAlgebra.qr(A::SparseMatrixCSC; tol = _default_tol(A)) = qr(A, Val{true}, tol = tol) -function LinearAlgebra.mul2!(Q::QRSparseQ, A::StridedVecOrMat) +function LinearAlgebra.lmul!(Q::QRSparseQ, A::StridedVecOrMat) if size(A, 1) != size(Q, 1) throw(DimensionMismatch("size(Q) = $(size(Q)) but size(A) = $(size(A))")) end @@ -213,7 +213,7 @@ function LinearAlgebra.mul2!(Q::QRSparseQ, A::StridedVecOrMat) return A end -function LinearAlgebra.mul1!(A::StridedMatrix, Q::QRSparseQ) +function LinearAlgebra.rmul!(A::StridedMatrix, Q::QRSparseQ) if size(A, 2) != size(Q, 1) throw(DimensionMismatch("size(Q) = $(size(Q)) but size(A) = $(size(A))")) end @@ -227,7 +227,7 @@ function LinearAlgebra.mul1!(A::StridedMatrix, Q::QRSparseQ) return A end -function LinearAlgebra.mul2!(adjQ::Adjoint{<:Any,<:QRSparseQ}, A::StridedVecOrMat) +function LinearAlgebra.lmul!(adjQ::Adjoint{<:Any,<:QRSparseQ}, A::StridedVecOrMat) Q = adjQ.parent if size(A, 1) != size(Q, 1) throw(DimensionMismatch("size(Q) = $(size(Q)) but size(A) = $(size(A))")) @@ -243,7 +243,7 @@ function LinearAlgebra.mul2!(adjQ::Adjoint{<:Any,<:QRSparseQ}, A::StridedVecOrMa return A end -function LinearAlgebra.mul1!(A::StridedMatrix, adjQ::Adjoint{<:Any,<:QRSparseQ}) +function LinearAlgebra.rmul!(A::StridedMatrix, adjQ::Adjoint{<:Any,<:QRSparseQ}) Q = adjQ.parent if size(A, 2) != size(Q, 1) throw(DimensionMismatch("size(Q) = $(size(Q)) but size(A) = $(size(A))")) @@ -375,7 +375,7 @@ function _ldiv_basic(F::QRSparse, B::StridedVecOrMat) X0 = view(X, 1:size(B, 1), :) # Apply Q' to B - LinearAlgebra.mul2!(adjoint(F.Q), X0) + LinearAlgebra.lmul!(adjoint(F.Q), X0) # Zero out to get basic solution X[rnk + 1:end, :] = 0 diff --git a/stdlib/SuiteSparse/test/spqr.jl b/stdlib/SuiteSparse/test/spqr.jl index c36545e173cd2..b3a413ac42cbc 100644 --- a/stdlib/SuiteSparse/test/spqr.jl +++ b/stdlib/SuiteSparse/test/spqr.jl @@ -2,7 +2,7 @@ using SuiteSparse.SPQR using SuiteSparse.CHOLMOD -using LinearAlgebra: mul1!, mul2!, Adjoint, Transpose +using LinearAlgebra: rmul!, lmul!, Adjoint, Transpose @testset "Sparse QR" begin m, n = 100, 10 @@ -43,10 +43,10 @@ nn = 100 @test norm(R0[n + 1:end, :], 1) < 1e-12 offsizeA = Matrix{Float64}(I, m+1, m+1) - @test_throws DimensionMismatch mul2!(Q, offsizeA) - @test_throws DimensionMismatch mul2!(adjoint(Q), offsizeA) - @test_throws DimensionMismatch mul1!(offsizeA, Q) - @test_throws DimensionMismatch mul1!(offsizeA, adjoint(Q)) + @test_throws DimensionMismatch lmul!(Q, offsizeA) + @test_throws DimensionMismatch lmul!(adjoint(Q), offsizeA) + @test_throws DimensionMismatch rmul!(offsizeA, Q) + @test_throws DimensionMismatch rmul!(offsizeA, adjoint(Q)) end @testset "element type of B: $eltyB" for eltyB in (Int, Float64, Complex{Float64})