Change mul1! and mul2! to rmul! and lmul! (JuliaLang#25812)

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

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/diagonal.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/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

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