Only add inplace methods for UpperOrLowerTriangular (#196)

* Only add inplace methods for UpperOrLowerTriangular

* Don't test against LazyArrays

* Set fail fast to false

* Disambiguate triangular multiplication

* Add missing tests

Author: jishnub

.github/workflows/downstream.yml

@@ -25,7 +25,7 @@ jobs:
     name: ${{ matrix.package.group }}/${{ matrix.package.repo }}/${{ matrix.julia-version }}
     runs-on: ${{ matrix.os }}
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
         julia-version: ['1']
         os: [ubuntu-latest]

Project.toml

@@ -1,7 +1,7 @@
 name = "ArrayLayouts"
 uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
 authors = ["Sheehan Olver <[email protected]>"]
-version = "1.5.1"
+version = "1.5.2"
 
 [deps]
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"

src/mul.jl

@@ -252,7 +252,7 @@ macro layoutmul(Typ)
             (*)(A::$Typ, B::LinearAlgebra.$Struc) = ArrayLayouts.mul(A,B)
         end
     end
-    for Mod in (:Adjoint, :Transpose, :Symmetric, :Hermitian, :UpperOrLowerTriangular)
+    for Mod in (:Adjoint, :Transpose, :Symmetric, :Hermitian)
         ret = quote
             $ret
 
@@ -297,6 +297,37 @@ macro layoutmul(Typ)
         end
     end
 
+    ret = quote
+        $ret
+
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::$Typ, b::UpperOrLowerTriangular) =
+            ArrayLayouts.mul!(dest,A,b)
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::UpperOrLowerTriangular, b::$Typ) =
+            ArrayLayouts.mul!(dest,A,b)
+        LinearAlgebra.mul!(dest::AbstractVector, A::UpperOrLowerTriangular{<:Any,<:$Typ}, b::AbstractVector) =
+            ArrayLayouts.mul!(dest,A,b)
+        LinearAlgebra.mul!(dest::AbstractVector, A::UpperOrLowerTriangular{<:Any,<:$Typ}, b::AbstractVector, α::Number, β::Number) =
+            ArrayLayouts.mul!(dest,A,b,α,β)
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::UpperOrLowerTriangular{<:Any,<:$Typ}, B::AbstractMatrix, α::Number, β::Number) =
+            ArrayLayouts.mul!(dest,A,B,α,β)
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::UpperOrLowerTriangular{<:Any,<:$Typ}, B::UpperOrLowerTriangular, α::Number, β::Number) =
+            ArrayLayouts.mul!(dest,A,B,α,β)
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::AbstractMatrix, B::UpperOrLowerTriangular{<:Any,<:$Typ}, α::Number, β::Number) =
+            ArrayLayouts.mul!(dest,A,B,α,β)
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::UpperOrLowerTriangular, B::UpperOrLowerTriangular{<:Any,<:$Typ}, α::Number, β::Number) =
+            ArrayLayouts.mul!(dest,A,B,α,β)
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::UpperOrLowerTriangular{<:Any,<:$Typ}, B::$Typ, α::Number, β::Number) =
+            ArrayLayouts.mul!(dest,A,B,α,β)
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::$Typ, B::UpperOrLowerTriangular{<:Any,<:$Typ}, α::Number, β::Number) =
+            ArrayLayouts.mul!(dest,A,B,α,β)
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::UpperOrLowerTriangular, B::$Typ, α::Number, β::Number) =
+            ArrayLayouts.mul!(dest,A,B,α,β)
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::$Typ, B::UpperOrLowerTriangular, α::Number, β::Number) =
+            ArrayLayouts.mul!(dest,A,B,α,β)
+        LinearAlgebra.mul!(dest::AbstractMatrix, A::UpperOrLowerTriangular{<:Any,<:$Typ}, B::UpperOrLowerTriangular{<:Any,<:$Typ}, α::Number, β::Number) =
+            ArrayLayouts.mul!(dest,A,B,α,β)
+
+    end
     esc(ret)
 end
 
@@ -316,6 +347,7 @@ end
 *(x::TransposeAbsVec{<:Any,<:Zeros{<:Any,1}}, D::Diagonal, y::LayoutVector) = FillArrays._triple_zeromul(x, D, y)
 
 
+*(A::UpperOrLowerTriangular{<:Any,<:LayoutMatrix}, B::UpperOrLowerTriangular{<:Any,<:LayoutMatrix}) = mul(A, B)
 *(A::UpperOrLowerTriangular{<:Any,<:AdjOrTrans{<:Any,<:LayoutMatrix}}, B::UpperOrLowerTriangular{<:Any,<:LayoutMatrix}) = mul(A, B)
 *(A::UpperOrLowerTriangular{<:Any,<:LayoutMatrix}, B::UpperOrLowerTriangular{<:Any,<:AdjOrTrans{<:Any,<:LayoutMatrix}}) = mul(A, B)
 *(A::UpperOrLowerTriangular{<:Any,<:AdjOrTrans{<:Any,<:LayoutMatrix}}, B::UpperOrLowerTriangular{<:Any,<:AdjOrTrans{<:Any,<:LayoutMatrix}}) = mul(A, B)

test/test_layoutarray.jl

@@ -536,6 +536,38 @@ MemoryLayout(::Type{MyVector}) = DenseColumnMajor()
     end
 end
 
+@testset "mul involving a triangular" begin
+    A = MyMatrix(rand(4,4))
+    UA = UpperTriangular(A)
+    MA = Matrix(A)
+    MUA = Matrix(UA)
+    B = rand(4,4)
+    UB = UpperTriangular(B)
+    @test mul!(zeros(4,4), A, UB) ≈ MA * UB
+    @test mul!(ones(4,4), A, UB, 2, 2) ≈ 2 * MA * UB .+ 2
+    @test mul!(zeros(4,4), UA, B) ≈ MUA * B
+    @test mul!(ones(4,4), UA, B, 2, 2) ≈ 2 * MUA * B .+ 2
+    @test mul!(zeros(4,4), UA, UB) ≈ MUA * UB
+    @test mul!(ones(4,4), UA, UB, 2, 2) ≈ 2 * MUA * UB .+ 2
+    @test mul!(zeros(4,4), UB, A) ≈ UB * MA
+    @test mul!(ones(4,4), UB, A, 2, 2) ≈ 2 * UB * MA .+ 2
+    @test mul!(zeros(4,4), UB, UA) ≈ UB * MUA
+    @test mul!(ones(4,4), UB, UA, 2, 2) ≈ 2 * UB * MUA .+ 2
+    @test mul!(zeros(4,4), B, UA) ≈ B * MUA
+    @test mul!(ones(4,4), B, UA, 2, 2) ≈ 2 * B * MUA .+ 2
+    @test mul!(zeros(4,4), A, UA) ≈ MA * MUA
+    @test mul!(ones(4,4), A, UA, 2, 2) ≈ 2 * MA * MUA .+ 2
+    @test mul!(zeros(4,4), UA, A) ≈ MUA * MA
+    @test mul!(ones(4,4), UA, A, 2, 2) ≈ 2 * MUA * MA .+ 2
+    @test mul!(zeros(4,4), UA, UA) ≈ MUA * MUA
+    @test mul!(ones(4,4), UA, UA, 2, 2) ≈ 2 * MUA * MUA .+ 2
+
+
+    v = rand(4)
+    @test mul!(zeros(4), UA, v) ≈ MUA * v
+    @test mul!(ones(4), UA, v, 2, 2) ≈ 2 * MUA * v .+ 2
+end
+
 struct MyUpperTriangular{T} <: AbstractMatrix{T}
     A::UpperTriangular{T,Matrix{T}}
 end

test/test_muladd.jl

@@ -785,7 +785,6 @@ Random.seed!(0)
             x :: T
             sz :: NTuple{2,Int}
         end
-        MFillMat(x::T, sz::NTuple{2,Int}) where {T} = MFillMat{T}(x, sz)
         MFillMat(x::T, sz::Vararg{Int,2}) where {T} = MFillMat{T}(x, sz)
         Base.size(M::MFillMat) = M.sz
         FillArrays.getindex_value(M::MFillMat) = M.x