Change mul1! and mul2! to rmul! and lmul!

Author: andreasnoack

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 ]

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!
 ```

stdlib/LinearAlgebra/src/LinearAlgebra.jl

@@ -115,8 +115,8 @@ export
     lufact!,
     lyap,
     mul!,
-    mul1!,
-    mul2!,
+    lmul!,
+    rmul!,
     norm,
     normalize,
     normalize!,

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)

stdlib/LinearAlgebra/src/deprecated.jl

@@ -151,116 +151,116 @@ 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
     UpperTriangular(B.data)
 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}) =
     Diagonal(adjoint.(D.parent.diag) .* adjoint.(B.parent.diag))
 *(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

stdlib/LinearAlgebra/src/diagonal.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

stdlib/LinearAlgebra/src/generic.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