diff --git a/src/LinearAlgebra.jl b/src/LinearAlgebra.jl index fc1081e0..2c76dcdc 100644 --- a/src/LinearAlgebra.jl +++ b/src/LinearAlgebra.jl @@ -16,6 +16,7 @@ import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, as permutedims, permuterows!, power_by_squaring, promote_rule, real, sec, sech, setindex!, show, similar, sin, sincos, sinh, size, sqrt, strides, stride, tan, tanh, transpose, trunc, typed_hcat, vec, view, zero +import Base: AbstractArray, AbstractMatrix, Array, Matrix using Base: IndexLinear, promote_eltype, promote_op, print_matrix, @propagate_inbounds, reduce, typed_hvcat, typed_vcat, require_one_based_indexing, splat, BitInteger diff --git a/src/adjtrans.jl b/src/adjtrans.jl index f7caa9bc..d81aa3ae 100644 --- a/src/adjtrans.jl +++ b/src/adjtrans.jl @@ -319,8 +319,8 @@ const AdjointAbsVec{T} = Adjoint{T,<:AbstractVector} const AdjointAbsMat{T} = Adjoint{T,<:AbstractMatrix} const TransposeAbsVec{T} = Transpose{T,<:AbstractVector} const TransposeAbsMat{T} = Transpose{T,<:AbstractMatrix} -const AdjOrTransAbsVec{T} = AdjOrTrans{T,<:AbstractVector} -const AdjOrTransAbsMat{T} = AdjOrTrans{T,<:AbstractMatrix} +const AdjOrTransAbsVec{T,V<:AbstractVector} = AdjOrTrans{T,V} +const AdjOrTransAbsMat{T,M<:AbstractMatrix} = AdjOrTrans{T,M} # for internal use below wrapperop(_) = identity diff --git a/src/blas.jl b/src/blas.jl index 3c156300..04e590c1 100644 --- a/src/blas.jl +++ b/src/blas.jl @@ -84,7 +84,8 @@ export trsm!, trsm -using ..LinearAlgebra: libblastrampoline, BlasReal, BlasComplex, BlasFloat, BlasInt, DimensionMismatch, checksquare, chkstride1 +using ..LinearAlgebra: libblastrampoline, BlasReal, BlasComplex, BlasFloat, BlasInt, + DimensionMismatch, checksquare, chkstride1, SingularException include("lbt.jl") @@ -1369,6 +1370,11 @@ for (fname, elty) in ((:dtrsv_,:Float64), throw(DimensionMismatch(lazy"size of A is $n != length(x) = $(length(x))")) end chkstride1(A) + if diag == 'N' + for i in 1:n + iszero(A[i,i]) && throw(SingularException(i)) + end + end px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) GC.@preserve x ccall((@blasfunc($fname), libblastrampoline), Cvoid, (Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, @@ -2217,6 +2223,11 @@ for (mmname, smname, elty) in end chkstride1(A) chkstride1(B) + if diag == 'N' + for i in 1:k + iszero(A[i,i]) && throw(SingularException(i)) + end + end ccall((@blasfunc($smname), libblastrampoline), Cvoid, (Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, diff --git a/src/dense.jl b/src/dense.jl index ccf6bc80..234391e5 100644 --- a/src/dense.jl +++ b/src/dense.jl @@ -972,7 +972,8 @@ sqrt(::AbstractMatrix) function sqrt(A::AbstractMatrix{T}) where {T<:Union{Real,Complex}} if checksquare(A) == 0 return copy(float(A)) - elseif isdiag(A) + elseif isdiag(A) && (T <: Complex || all(x -> x ≥ zero(x), diagview(A))) + # Real Diagonal sqrt requires each diagonal element to be positive return applydiagonal(sqrt, A) elseif ishermitian(A) sqrtHermA = sqrt(Hermitian(A)) diff --git a/src/diagonal.jl b/src/diagonal.jl index 9f8d54e5..8ded64ad 100644 --- a/src/diagonal.jl +++ b/src/diagonal.jl @@ -332,6 +332,28 @@ function (*)(D::Diagonal, V::AbstractVector) return D.diag .* V end +function _diag_adj_mul(A::AdjOrTransAbsMat, D::Diagonal) + adj = wrapperop(A) + copy(adj(adj(D) * adj(A))) +end +function _diag_adj_mul(A::AdjOrTransAbsMat{<:Number, <:StridedMatrix}, D::Diagonal{<:Number}) + @invoke *(A::AbstractMatrix, D::AbstractMatrix) +end +function _diag_adj_mul(D::Diagonal, A::AdjOrTransAbsMat) + adj = wrapperop(A) + copy(adj(adj(A) * adj(D))) +end +function _diag_adj_mul(D::Diagonal{<:Number}, A::AdjOrTransAbsMat{<:Number, <:StridedMatrix}) + @invoke *(D::AbstractMatrix, A::AbstractMatrix) +end + +function (*)(A::AdjOrTransAbsMat, D::Diagonal) + _diag_adj_mul(A, D) +end +function (*)(D::Diagonal, A::AdjOrTransAbsMat) + _diag_adj_mul(D, A) +end + function rmul!(A::AbstractMatrix, D::Diagonal) matmul_size_check(size(A), size(D)) for I in CartesianIndices(A) @@ -671,22 +693,24 @@ end for Tri in (:UpperTriangular, :LowerTriangular) UTri = Symbol(:Unit, Tri) # 2 args - for (fun, f) in zip((:*, :rmul!, :rdiv!, :/), (:identity, :identity, :inv, :inv)) - @eval $fun(A::$Tri, D::Diagonal) = $Tri($fun(A.data, D)) - @eval $fun(A::$UTri, D::Diagonal) = $Tri(_setdiag!($fun(A.data, D), $f, D.diag)) + for (fun, f) in zip((:mul, :rmul!, :rdiv!, :/), (:identity, :identity, :inv, :inv)) + g = fun == :mul ? :* : fun + @eval $fun(A::$Tri, D::Diagonal) = $Tri($g(A.data, D)) + @eval $fun(A::$UTri, D::Diagonal) = $Tri(_setdiag!($g(A.data, D), $f, D.diag)) end - @eval *(A::$Tri{<:Any, <:StridedMaybeAdjOrTransMat}, D::Diagonal) = - @invoke *(A::AbstractMatrix, D::Diagonal) - @eval *(A::$UTri{<:Any, <:StridedMaybeAdjOrTransMat}, D::Diagonal) = - @invoke *(A::AbstractMatrix, D::Diagonal) - for (fun, f) in zip((:*, :lmul!, :ldiv!, :\), (:identity, :identity, :inv, :inv)) - @eval $fun(D::Diagonal, A::$Tri) = $Tri($fun(D, A.data)) - @eval $fun(D::Diagonal, A::$UTri) = $Tri(_setdiag!($fun(D, A.data), $f, D.diag)) + @eval mul(A::$Tri{<:Any, <:StridedMaybeAdjOrTransMat}, D::Diagonal) = + @invoke mul(A::AbstractMatrix, D::Diagonal) + @eval mul(A::$UTri{<:Any, <:StridedMaybeAdjOrTransMat}, D::Diagonal) = + @invoke mul(A::AbstractMatrix, D::Diagonal) + for (fun, f) in zip((:mul, :lmul!, :ldiv!, :\), (:identity, :identity, :inv, :inv)) + g = fun == :mul ? :* : fun + @eval $fun(D::Diagonal, A::$Tri) = $Tri($g(D, A.data)) + @eval $fun(D::Diagonal, A::$UTri) = $Tri(_setdiag!($g(D, A.data), $f, D.diag)) end - @eval *(D::Diagonal, A::$Tri{<:Any, <:StridedMaybeAdjOrTransMat}) = - @invoke *(D::Diagonal, A::AbstractMatrix) - @eval *(D::Diagonal, A::$UTri{<:Any, <:StridedMaybeAdjOrTransMat}) = - @invoke *(D::Diagonal, A::AbstractMatrix) + @eval mul(D::Diagonal, A::$Tri{<:Any, <:StridedMaybeAdjOrTransMat}) = + @invoke mul(D::Diagonal, A::AbstractMatrix) + @eval mul(D::Diagonal, A::$UTri{<:Any, <:StridedMaybeAdjOrTransMat}) = + @invoke mul(D::Diagonal, A::AbstractMatrix) # 3-arg ldiv! @eval ldiv!(C::$Tri, D::Diagonal, A::$Tri) = $Tri(ldiv!(C.data, D, A.data)) @eval ldiv!(C::$Tri, D::Diagonal, A::$UTri) = $Tri(_setdiag!(ldiv!(C.data, D, A.data), inv, D.diag)) diff --git a/src/matmul.jl b/src/matmul.jl index 76719c53..84a83d3a 100644 --- a/src/matmul.jl +++ b/src/matmul.jl @@ -111,7 +111,9 @@ julia> [1 1; 0 1] * [1 0; 1 1] 1 1 ``` """ -function (*)(A::AbstractMatrix, B::AbstractMatrix) +(*)(A::AbstractMatrix, B::AbstractMatrix) = mul(A, B) +# we add an extra level of indirection to avoid ambiguities in * +function mul(A::AbstractMatrix, B::AbstractMatrix) TS = promote_op(matprod, eltype(A), eltype(B)) mul!(matprod_dest(A, B, TS), A, B) end @@ -1021,6 +1023,7 @@ function _generic_matmatmul_nonadjtrans!(C, A, B, alpha, beta) @inbounds for n in axes(B, 2), k in axes(B, 1) # Balpha = B[k,n] * alpha, but we skip the multiplication in case isone(alpha) Balpha = @stable_muladdmul MulAddMul(alpha, false)(B[k,n]) + !ismissing(Balpha) && iszero(Balpha) && continue @simd for m in axes(A, 1) C[m,n] = muladd(A[m,k], Balpha, C[m,n]) end diff --git a/src/triangular.jl b/src/triangular.jl index 5c6b5188..3faa12da 100644 --- a/src/triangular.jl +++ b/src/triangular.jl @@ -1223,11 +1223,13 @@ function generic_mattrimul!(C::StridedMatrix{T}, uploc, isunitc, tfun::Function, end end # division -function generic_trimatdiv!(C::StridedVecOrMat{T}, uploc, isunitc, tfun::Function, A::StridedMatrix{T}, B::AbstractVecOrMat{T}) where {T<:BlasFloat} +generic_trimatdiv!(C::StridedVector{T}, uploc, isunitc, tfun::Function, A::StridedMatrix{T}, B::AbstractVector{T}) where {T<:BlasFloat} = + BLAS.trsv!(uploc, tfun === identity ? 'N' : tfun === transpose ? 'T' : 'C', isunitc, A, C === B ? C : copyto!(C, B)) +function generic_trimatdiv!(C::StridedMatrix{T}, uploc, isunitc, tfun::Function, A::StridedMatrix{T}, B::AbstractMatrix{T}) where {T<:BlasFloat} if stride(C,1) == stride(A,1) == 1 - LAPACK.trtrs!(uploc, tfun === identity ? 'N' : tfun === transpose ? 'T' : 'C', isunitc, A, C === B ? C : copyto!(C, B)) + BLAS.trsm!('L', uploc, tfun === identity ? 'N' : tfun === transpose ? 'T' : 'C', isunitc, one(T), A, C === B ? C : copyto!(C, B)) else # incompatible with LAPACK - @invoke generic_trimatdiv!(C::AbstractVecOrMat, uploc, isunitc, tfun::Function, A::AbstractMatrix, B::AbstractVecOrMat) + @invoke generic_trimatdiv!(C::AbstractVecOrMat, uploc, isunitc, tfun::Function, A::AbstractMatrix, B::AbstractMatrix) end end function generic_mattridiv!(C::StridedMatrix{T}, uploc, isunitc, tfun::Function, A::AbstractMatrix{T}, B::StridedMatrix{T}) where {T<:BlasFloat} diff --git a/test/dense.jl b/test/dense.jl index 1f953ea9..1d4b330c 100644 --- a/test/dense.jl +++ b/test/dense.jl @@ -984,6 +984,12 @@ end @testset "sqrt for diagonal" begin A = diagm(0 => [1, 2, 3]) @test sqrt(A)^2 ≈ A + + A = diagm(0 => [1.0, -1.0]) + @test sqrt(A) == diagm(0 => [1.0, 1.0im]) + @test sqrt(A)^2 ≈ A + B = im*A + @test sqrt(B)^2 ≈ B end @testset "issue #40141" begin diff --git a/test/matmul.jl b/test/matmul.jl index 805edeac..afa730f1 100644 --- a/test/matmul.jl +++ b/test/matmul.jl @@ -767,6 +767,7 @@ import LinearAlgebra: Adjoint, Transpose (*)(x::RootInt, y::Integer) = x.i * y adjoint(x::RootInt) = x transpose(x::RootInt) = x +Base.zero(::RootInt) = RootInt(0) @test Base.promote_op(*, RootInt, RootInt) === Int diff --git a/test/testtriag.jl b/test/testtriag.jl index 7542d843..6ed7a0d6 100644 --- a/test/testtriag.jl +++ b/test/testtriag.jl @@ -493,6 +493,8 @@ function test_triangular(elty1_types) @test_throws DimensionMismatch transpose(Ann) \ bm if t1 == UpperTriangular || t1 == LowerTriangular @test_throws SingularException ldiv!(t1(zeros(elty1, n, n)), fill(eltyB(1), n)) + @test_throws SingularException ldiv!(t1(zeros(elty1, n, n)), fill(eltyB(1), n, 2)) + @test_throws SingularException rdiv!(fill(eltyB(1), n, n), t1(zeros(elty1, n, n))) end @test B / A1 ≈ B / M1 @test B / transpose(A1) ≈ B / transpose(M1) diff --git a/test/triangular.jl b/test/triangular.jl index a5fa45d0..8eeeb666 100644 --- a/test/triangular.jl +++ b/test/triangular.jl @@ -886,8 +886,13 @@ end end end -@testset "(l/r)mul! and (l/r)div! for non-contiguous matrices" begin +@testset "(l/r)mul! and (l/r)div! for non-contiguous arrays" begin U = UpperTriangular(reshape(collect(3:27.0),5,5)) + b = float.(1:10) + b2 = copy(b); b2v = view(b2, 1:2:9); b2vc = copy(b2v) + @test lmul!(U, b2v) == lmul!(U, b2vc) + b2 = copy(b); b2v = view(b2, 1:2:9); b2vc = copy(b2v) + @test ldiv!(U, b2v) ≈ ldiv!(U, b2vc) B = float.(collect(reshape(1:100, 10,10))) B2 = copy(B); B2v = view(B2, 1:2:9, 1:5); B2vc = copy(B2v) @test lmul!(U, B2v) == lmul!(U, B2vc)