Add some three-argument ldiv! methods (#33806)

Author: antoine-levitt

stdlib/LinearAlgebra/src/diagonal.jl

@@ -427,7 +427,7 @@ function ldiv!(D::Diagonal{T}, V::AbstractMatrix{T}) where {T}
     end
     V
 end
-
+ldiv!(x::AbstractArray, A::Diagonal, b::AbstractArray) = (x .= A.diag .\ b)
 
 ldiv!(adjD::Adjoint{<:Any,<:Diagonal{T}}, B::AbstractVecOrMat{T}) where {T} =
     (D = adjD.parent; ldiv!(conj(D), B))

stdlib/LinearAlgebra/src/factorization.jl

@@ -140,15 +140,6 @@ function ldiv!(Y::AbstractVecOrMat, A::Factorization, B::AbstractVecOrMat)
     end
 end
 
-function ldiv!(Y::AbstractVecOrMat, adjA::Adjoint{<:Any,<:Factorization}, B::AbstractVecOrMat)
-    checksquare(adjA)
-    return ldiv!(adjA, copyto!(Y, B))
-end
-function ldiv!(Y::AbstractVecOrMat, transA::Transpose{<:Any,<:Factorization}, B::AbstractVecOrMat)
-    checksquare(transA)
-    return ldiv!(transA, copyto!(Y, B))
-end
-
 # fallback methods for transposed solves
 \(F::Transpose{<:Any,<:Factorization{<:Real}}, B::AbstractVecOrMat) = adjoint(F.parent) \ B
 \(F::Transpose{<:Any,<:Factorization}, B::AbstractVecOrMat) = conj.(adjoint(F.parent) \ conj.(B))

stdlib/LinearAlgebra/src/generic.jl

@@ -241,6 +241,11 @@ function ldiv!(s::Number, X::AbstractArray)
     end
     X
 end
+ldiv!(Y::AbstractArray, s::Number, X::AbstractArray) = Y .= s .\ X
+
+# Generic fallback. This assumes that B and Y have the same sizes.
+ldiv!(Y::AbstractArray, A::AbstractMatrix, B::AbstractArray) = ldiv!(A, copyto!(Y, B))
+
 
 """
     cross(x, y)

stdlib/LinearAlgebra/src/uniformscaling.jl

@@ -222,6 +222,7 @@ rmul!(A::AbstractMatrix, J::UniformScaling) = rmul!(A, J.λ)
 lmul!(J::UniformScaling, B::AbstractVecOrMat) = lmul!(J.λ, B)
 rdiv!(A::AbstractMatrix, J::UniformScaling) = rdiv!(A, J.λ)
 ldiv!(J::UniformScaling, B::AbstractVecOrMat) = ldiv!(J.λ, B)
+ldiv!(Y::AbstractVecOrMat, J::UniformScaling, B::AbstractVecOrMat) = (Y .= J.λ .\ B)
 
 Broadcast.broadcasted(::typeof(*), x::Number,J::UniformScaling) = UniformScaling(x*J.λ)
 Broadcast.broadcasted(::typeof(*), J::UniformScaling,x::Number) = UniformScaling(J.λ*x)

stdlib/LinearAlgebra/test/diagonal.jl

@@ -115,6 +115,14 @@ Random.seed!(1)
                 @test ldiv!(D, copy(U)) ≈ DM\U atol=atol_three
                 @test ldiv!(transpose(D), copy(U)) ≈ DM\U atol=atol_three
                 @test ldiv!(adjoint(conj(D)), copy(U)) ≈ DM\U atol=atol_three
+
+                @test ldiv!(zero(v), D, copy(v)) ≈ DM\v atol=atol_two
+                @test ldiv!(zero(v), transpose(D), copy(v)) ≈ DM\v atol=atol_two
+                @test ldiv!(zero(v), adjoint(conj(D)), copy(v)) ≈ DM\v atol=atol_two
+                @test ldiv!(zero(U), D, copy(U)) ≈ DM\U atol=atol_three
+                @test ldiv!(zero(U), transpose(D), copy(U)) ≈ DM\U atol=atol_three
+                @test ldiv!(zero(U), adjoint(conj(D)), copy(U)) ≈ DM\U atol=atol_three
+
                 Uc = copy(U')
                 target = rmul!(Uc, Diagonal(inv.(D.diag)))
                 @test rdiv!(Uc, D) ≈ target atol=atol_three

stdlib/LinearAlgebra/test/generic.jl

@@ -119,6 +119,7 @@ end
         @testset "Scaling with rdiv! and ldiv!" begin
             @test rdiv!(copy(a), 5.) == a/5
             @test ldiv!(5., copy(a)) == a/5
+            @test ldiv!(zero(a), 5., copy(a)) == a/5
         end
 
         @testset "Scaling with 3-argument mul!" begin

stdlib/LinearAlgebra/test/uniformscaling.jl

@@ -326,6 +326,7 @@ end
     @test lmul!(J, copyto!(C, A)) == target_mul
     @test rmul!(copyto!(C, A), J) == target_mul
     @test ldiv!(J, copyto!(C, A)) == target_div
+    @test ldiv!(C, J, A) == target_div
     @test rdiv!(copyto!(C, A), J) == target_div
 
     A = randn(4, 3)