Merge branch 'master' of https://github.com/JuliaLinearAlgebra/ArrayLayouts.jl

Author: dlfivefifty

.github/dependabot.yml

@@ -0,0 +1,7 @@
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

.github/workflows/ci.yml

@@ -14,19 +14,20 @@ jobs:
         version:
           - '1.6'
           - '1'
+          - '^1.9.0-0'          
         os:
           - ubuntu-latest
           - macOS-latest
           - windows-latest
         arch:
           - x64
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: julia-actions/setup-julia@v1
         with:
           version: ${{ matrix.version }}
           arch: ${{ matrix.arch }}
-      - uses: actions/cache@v1
+      - uses: actions/cache@v3
         env:
           cache-name: cache-artifacts
         with:
@@ -39,14 +40,14 @@ jobs:
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
       - uses: julia-actions/julia-processcoverage@v1
-      - uses: codecov/codecov-action@v1
+      - uses: codecov/codecov-action@v3
         with:
           file: lcov.info
   docs:
     name: Documentation
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: julia-actions/setup-julia@v1
         with:
           version: '1'

.github/workflows/downstream.yml

@@ -0,0 +1,69 @@
+name: IntegrationTest
+on:
+  push:
+    branches: [master]
+    tags: [v*]
+  pull_request:
+    paths-ignore:
+      - 'LICENSE'
+      - 'README.md'
+      - '.github/workflows/TagBot.yml'
+
+jobs:
+  pre_job:
+    # continue-on-error: true # Uncomment once integration is finished
+    runs-on: ubuntu-latest
+    # Map a step output to a job output
+    outputs:
+      should_skip: ${{ steps.skip_check.outputs.should_skip }}
+    steps:
+      - id: skip_check
+        uses: fkirc/skip-duplicate-actions@v5
+  test:
+    needs: pre_job
+    if: needs.pre_job.outputs.should_skip != 'true'
+    name: ${{ matrix.package.group }}/${{ matrix.package.repo }}/${{ matrix.julia-version }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: true
+      matrix:
+        julia-version: ['1']
+        os: [ubuntu-latest]
+        package:
+          - {repo: BlockArrays.jl, group: JuliaArrays}
+          - {repo: BandedMatrices.jl, group: JuliaLinearAlgebra}
+          - {repo: BlockBandedMatrices.jl, group: JuliaLinearAlgebra}
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: julia-actions/setup-julia@v1
+        with:
+          version: ${{ matrix.julia-version }}
+          arch: x64
+      - uses: julia-actions/julia-buildpkg@latest
+      - name: Clone Downstream
+        uses: actions/checkout@v3
+        with:
+          repository: ${{ matrix.package.group }}/${{ matrix.package.repo }}
+          path: downstream
+      - name: Load this and run the downstream tests
+        shell: julia --color=yes --project=downstream {0}
+        run: |
+          using Pkg
+          try
+            # force it to use this PR's version of the package
+            Pkg.develop(PackageSpec(path="."))  # resolver may fail with main deps
+            Pkg.update()
+            Pkg.test(; coverage = true)  # resolver may fail with test time deps
+          catch err
+            err isa Pkg.Resolve.ResolverError || rethrow()
+            # If we can't resolve that means this is incompatible by SemVer and this is fine
+            # It means we marked this as a breaking change, so we don't need to worry about
+            # Mistakenly introducing a breaking change, as we have intentionally made one
+            @info "Not compatible with this release. No problem." exception=err
+            exit(0)  # Exit immediately, as a success
+          end
+      - uses: julia-actions/julia-processcoverage@v1
+      - uses: codecov/codecov-action@v3
+        with:
+          files: lcov.info

Project.toml

@@ -1,7 +1,7 @@
 name = "ArrayLayouts"
 uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
 authors = ["Sheehan Olver <solver@mac.com>"]
-version = "0.8.16"
+version = "0.8.18"
 
 [deps]
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"

src/ArrayLayouts.jl

@@ -15,8 +15,8 @@ using Base.Broadcast: Broadcasted
 
 import Base.Broadcast: BroadcastStyle, broadcastable, instantiate, materialize, materialize!
 
-using LinearAlgebra: AbstractTriangular, AbstractQ, QRCompactWYQ, QRPackedQ, checksquare,
-                        pinv, tilebufsize, cholcopy,
+using LinearAlgebra: AbstractQ, QRCompactWYQ, QRPackedQ, HessenbergQ,
+                        AbstractTriangular, checksquare, pinv, tilebufsize, cholcopy,
                         norm2, norm1, normInf, normMinusInf,
                         AdjOrTrans, HermOrSym, RealHermSymComplexHerm, AdjointAbsVec, TransposeAbsVec,
                         checknonsingular, _apply_ipiv_rows!, ipiv2perm, chkfullrank

src/ldiv.jl

@@ -135,6 +135,7 @@ macro _layoutldiv(Typ)
         LinearAlgebra.ldiv!(A::Factorization, x::$Typ; kwds...) = ArrayLayouts.ldiv!(A,x; kwds...)
         LinearAlgebra.ldiv!(A::LU, x::$Typ; kwds...) = ArrayLayouts.ldiv!(A,x; kwds...)
         LinearAlgebra.ldiv!(A::Cholesky, x::$Typ; kwds...) = ArrayLayouts.ldiv!(A,x; kwds...)
+        LinearAlgebra.ldiv!(A::LinearAlgebra.QRCompactWY, x::$Typ; kwds...) = ArrayLayouts.ldiv!(A,x; kwds...)
 
         LinearAlgebra.ldiv!(A::Bidiagonal, B::$Typ; kwds...) = ArrayLayouts.ldiv!(A,B; kwds...)
 

src/mul.jl

@@ -88,7 +88,21 @@ check_mul_axes(A) = nothing
 _check_mul_axes(::Number, ::Number) = nothing
 _check_mul_axes(::Number, _) = nothing
 _check_mul_axes(_, ::Number) = nothing
-_check_mul_axes(A, B) = axes(A,2) == axes(B,1) || throw(DimensionMismatch("Second axis of A, $(axes(A,2)), and first axis of B, $(axes(B,1)) must match"))
+_check_mul_axes(A, B) = axes(A, 2) == axes(B, 1) || throw(DimensionMismatch("Second axis of A, $(axes(A,2)), and first axis of B, $(axes(B,1)) must match"))
+# we need to special case AbstractQ as it allows non-compatiple multiplication
+const FlexibleLeftQs = Union{QRCompactWYQ,QRPackedQ,HessenbergQ}
+_check_mul_axes(::FlexibleLeftQs, ::Number) = nothing
+_check_mul_axes(Q::FlexibleLeftQs, B) =
+    axes(Q.factors, 1) == axes(B, 1) || axes(Q.factors, 2) == axes(B, 1) ||
+        throw(DimensionMismatch("First axis of B, $(axes(B,1)) must match either axes of A, $(axes(Q.factors))"))
+_check_mul_axes(::Number, ::AdjointQtype{<:Any,<:FlexibleLeftQs}) = nothing
+function _check_mul_axes(A, adjQ::AdjointQtype{<:Any,<:FlexibleLeftQs})
+    Q = parent(adjQ)
+    axes(A, 2) == axes(Q.factors, 1) || axes(A, 2) == axes(Q.factors, 2) ||
+        throw(DimensionMismatch("Second axis of A, $(axes(A,2)) must match either axes of B, $(axes(Q.factors))"))
+end
+_check_mul_axes(Q::FlexibleLeftQs, adjQ::AdjointQtype{<:Any,<:FlexibleLeftQs}) =
+    invoke(_check_mul_axes, Tuple{Any,Any}, Q, adjQ)
 function check_mul_axes(A, B, C...)
     _check_mul_axes(A, B)
     check_mul_axes(B, C...)
@@ -118,8 +132,6 @@ mul!(dest::AbstractArray, A::AbstractArray, B::AbstractArray, α::Number, β::Nu
 
 broadcastable(M::Mul) = M
 
-const FlexibleLeftQs = Union{LinearAlgebra.HessenbergQ, LinearAlgebra.QRCompactWYQ, LinearAlgebra.QRPackedQ}
-
 macro veclayoutmul(Typ)
     ret = quote
         (*)(A::AbstractMatrix, B::$Typ) = ArrayLayouts.mul(A,B)
@@ -139,6 +151,7 @@ macro veclayoutmul(Typ)
         ret = quote
             $ret
 
+            const FlexibleLeftQs = Union{LinearAlgebra.HessenbergQ, LinearAlgebra.QRCompactWYQ, LinearAlgebra.QRPackedQ}
             # disambiguation for flexible left-mul Qs
             (*)(A::FlexibleLeftQs, B::$Typ) = ArrayLayouts.mul(A,B)
             # flexible right-mul/adjoint left-mul Qs
@@ -213,6 +226,7 @@ macro layoutmul(Typ)
         ret = quote
             $ret
 
+            const FlexibleLeftQs = Union{LinearAlgebra.HessenbergQ, LinearAlgebra.QRCompactWYQ, LinearAlgebra.QRPackedQ}
             # disambiguation for flexible left-mul/adjoint right-mul Qs
             (*)(A::FlexibleLeftQs, B::$Typ) = ArrayLayouts.mul(A,B)
             (*)(A::$Typ, B::LinearAlgebra.AdjointQ{<:Any,<:FlexibleLeftQs}) = ArrayLayouts.mul(A,B)

test/test_layoutarray.jl

@@ -129,8 +129,16 @@ MemoryLayout(::Type{MyVector}) = DenseColumnMajor()
 
             @testset "ldiv!" begin
                 c = MyVector(randn(5))
-                @test_broken ldiv!(lu(A), MyVector(copy(c))) ≈ A \ c
-                @test_throws ErrorException ldiv!(qr(A), MyVector(copy(c)))
+                if VERSION < v"1.9-"
+                    @test_broken ldiv!(lu(A), MyVector(copy(c))) ≈ A \ c
+                else
+                    @test ldiv!(lu(A), MyVector(copy(c))) ≈ A \ c
+                end
+                if VERSION < v"1.9-" || VERSION >= v"1.10-"
+                    @test_throws ErrorException ldiv!(qr(A), MyVector(copy(c)))
+                else
+                    @test_throws MethodError ldiv!(qr(A), MyVector(copy(c)))
+                end
                 @test_throws ErrorException ldiv!(eigen(randn(5,5)), c)
                 @test ArrayLayouts.ldiv!(svd(A.A), copy(c)) ≈ ArrayLayouts.ldiv!(similar(c), svd(A.A), c) ≈ A \ c 
                 if VERSION ≥ v"1.8"

test/test_muladd.jl

@@ -615,9 +615,12 @@ Random.seed!(0)
         Q = qr(randn(5,5)).Q
         b = randn(5)
         B = randn(5,5)
+        @test Q*1.0 == ArrayLayouts.lmul!(Q, Matrix{Float64}(I, 5, 5))
         @test Q*b == ArrayLayouts.lmul!(Q, copy(b)) == mul(Q,b)
         @test Q*B == ArrayLayouts.lmul!(Q, copy(B)) == mul(Q,B)
         @test B*Q == ArrayLayouts.rmul!(copy(B), Q) == mul(B,Q)
+        @test 1.0*Q ≈ ArrayLayouts.rmul!(Matrix{Float64}(I, 5, 5), Q)
+        @test 1.0*Q' ≈ ArrayLayouts.rmul!(Matrix{Float64}(I, 5, 5), Q')
         @test Q*Q ≈ mul(Q,Q)
         @test Q'*b == ArrayLayouts.lmul!(Q', copy(b)) == mul(Q',b)
         @test Q'*B == ArrayLayouts.lmul!(Q', copy(B)) == mul(Q',B)
@@ -627,6 +630,21 @@ Random.seed!(0)
         @test Q'*Q ≈ mul(Q',Q)
         @test Q*UpperTriangular(B) ≈ mul(Q, UpperTriangular(B))
         @test UpperTriangular(B)*Q ≈ mul(UpperTriangular(B), Q)
+
+        Q = qr(randn(7,5)).Q
+        b = randn(5)
+        B = randn(5,5)
+        @test Q*1.0 == ArrayLayouts.lmul!(Q, Matrix{Float64}(I, 7, 7))
+        @test Q*b == mul(Q,b)
+        @test Q*B == mul(Q,B)
+        @test 1.0*Q ≈ ArrayLayouts.rmul!(Matrix{Float64}(I, 7, 7), Q)
+        @test Q*Q ≈ mul(Q,Q)
+        @test B*Q' == mul(B,Q')
+        @test Q*Q' ≈ mul(Q,Q')
+        @test Q'*Q' ≈ mul(Q',Q')
+        @test Q'*Q ≈ mul(Q',Q)
+        VERSION >= v"1.8-" && @test Q*UpperTriangular(B) ≈ mul(Q, UpperTriangular(B))
+        @test UpperTriangular(B)*Q' ≈ mul(UpperTriangular(B), Q')
     end
 
     @testset "Mul" begin