Revert "abstractq"

This reverts commit 4137e6b.

Author: dlfivefifty

Project.toml

@@ -19,8 +19,8 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
 ArrayLayouts = "0.2.3"
-BandedMatrices = "0.15.5"
+BandedMatrices = "0.15.2"
 BlockArrays = "0.12"
 FillArrays = "0.8"
-MatrixFactorizations = "0.4"
+MatrixFactorizations = "0.3.1"
 julia = "1.2"

src/AbstractBlockBandedMatrix.jl

@@ -64,12 +64,6 @@ for Func in (:blockbanded_blockcolstart, :blockbanded_blockcolstop, :blockbanded
     @eval $Func(A, i::Block{1}) = $Func(A, Int(i))
 end
 
-blockbanded_blockcolstart(A, i::BlockRange) = blockbanded_blockcolstart(A, minimum(i))
-blockbanded_blocktowstart(A, i::BlockRange) = blockbanded_blockrowstart(A, minimum(i))
-blockbanded_blockcolstop(A, i::BlockRange) = blockbanded_blockcolstop(A, maximum(i))
-blockbanded_blocktowstop(A, i::BlockRange) = blockbanded_blockrowstop(A, maximum(i))
-
-
 @inline blockcolsupport(::AbstractBlockBandedLayout, A, i) = blockbanded_blockcolstart(A,i):blockbanded_blockcolstop(A,i)
 @inline blockrowsupport(::AbstractBlockBandedLayout, A, i) = blockbanded_blockrowstart(A,i):blockbanded_blockrowstop(A,i)
 

src/BandedBlockBandedMatrix.jl

@@ -175,10 +175,8 @@ function BandedBlockBandedMatrix{T,Blocks,RR}(A::AbstractMatrix, axes::NTuple{2,
 end
 
 
-BandedBlockBandedMatrix{T}(A::AbstractMatrix) where T =
-    copyto!(BandedBlockBandedMatrix{T}(undef, axes(A), blockbandwidths(A), subblockbandwidths(A)), A)
-
-BandedBlockBandedMatrix(A::AbstractMatrix{T}) where T = BandedBlockBandedMatrix{T}(A)
+BandedBlockBandedMatrix(A::AbstractMatrix) =
+    BandedBlockBandedMatrix(A, axes(A), blockbandwidths(A), subblockbandwidths(A))
 
 BandedBlockBandedMatrix(A::AbstractMatrix, rdims::AbstractVector{Int}, cdims::AbstractVector{Int}, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) =
     BandedBlockBandedMatrix(A, (blockedrange(rdims), blockedrange(cdims)), lu, λμ)
@@ -443,7 +441,7 @@ function blockbandwidths(V::SubBandedBlockBandedMatrix{<:Any,BlockRange1,BlockRa
 
     KR = parentindices(V)[1].block.indices[1]
     JR = parentindices(V)[2].block.indices[1]
-    shift = Int(first(KR))-Int(first(JR))
+    shift = Int(KR[1])-Int(JR[1])
 
     blockbandwidth(A,1) - shift, blockbandwidth(A,2) + shift
 end
@@ -489,7 +487,7 @@ parentblocks2Int(V::BandedBlockBandedBlock)::Tuple{Int,Int} = Int(first(parentin
 ######################################
 # BandedMatrix interface  for Blocks #
 ######################################
-@inline function bandwidths(V::SubArray{T,2,<:AbstractMatrix,<:Tuple{BlockSlice1,BlockSlice1}}) where T
+@inline function bandwidths(V::BandedBlockBandedBlock) 
     inblockbands(V) && return subblockbandwidths(parent(V))
     (-720,-720)
 end

src/BlockBandedMatrices.jl

@@ -18,7 +18,7 @@ import LinearAlgebra: UniformScaling, isdiag, rmul!, lmul!, ldiv!, rdiv!,
 import LinearAlgebra.BLAS: BlasInt, BlasFloat, @blasfunc, libblas, BlasComplex, BlasReal
 import LinearAlgebra.LAPACK: chktrans, chkdiag, liblapack, chklapackerror, checksquare, chkstride1,
                     chkuplo
-import MatrixFactorizations: ql, ql!, _ql, QLPackedQ, AdjQRPackedQLayout, AdjQLPackedQLayout
+import MatrixFactorizations: ql, ql!, _ql, QLPackedQ
 import SparseArrays: sparse
 
 import ArrayLayouts: BlasMatLmulVec,

src/blockskylineqr.jl

@@ -16,32 +16,21 @@ _apply_ql!(::AbstractColumnMajor, ::AbstractStridedLayout, ::AbstractStridedLayo
     LAPACK.ormql!('L','C',A,τ,B)
 apply_ql!(A, τ, B) = _apply_ql!(MemoryLayout(typeof(A)), MemoryLayout(typeof(τ)), MemoryLayout(typeof(B)), A, τ, B)
 
-function _blockbanded_qr!(A::AbstractMatrix, τ::AbstractVector)
-    M,N = Block.(blocksize(A))
-    (M < N ? axes(A,1) : axes(A,2)) == axes(τ,1) || throw(DimensionMismatch(""))
-    _blockbanded_qr!(A, τ, min(N,M))
-    QR(A,τ.blocks)
-end
-
-function _blockbanded_qr!(A::AbstractMatrix, τ::AbstractVector, NCOLS::Block{1})
+function qr!(A::BlockBandedMatrix{T}) where T
     l,u = blockbandwidths(A)
-    M,N = Block.(blocksize(A))
-    for K = Block(1):NCOLS
-        KR = K:min(K+l,M)
-        V = view(A,KR,K)
-        t = view(τ,K)
+    M,N = blocksize(A)
+    ax1 = M < N ? axes(A,1) : axes(A,2)
+    τ = PseudoBlockVector{T}(undef, (ax1,))
+    for K = 1:min(N,M)
+        KR = Block.(K:min(K+l,M))
+        V = view(A,KR,Block(K))
+        t = view(τ,Block(K))
         qrf!(V,t)
         for J = K+1:min(K+u,N)
-            apply_qr!(V, t, view(A,KR,J))
+            apply_qr!(V, t, view(A,KR,Block(J)))
         end
     end
-    A,τ
-end
-
-function qr!(A::BlockBandedMatrix{T}) where T 
-    M,N = blocksize(A)
-    ax1 = M < N ? axes(A,1) : axes(A,2)
-    _blockbanded_qr!(A, PseudoBlockVector{T}(undef, (ax1,)))
+    QR(A,τ.blocks)
 end
 
 function ql!(A::BlockBandedMatrix{T}) where T
@@ -68,13 +57,11 @@ function ql!(A::BlockBandedMatrix{T}) where T
     QL(A,τ.blocks)
 end
 
-_qr(::AbstractBlockBandedLayout, ::Tuple{Integer,Integer}, A) = qr!(BlockBandedMatrix(A, (blockbandwidth(A,1), blockbandwidth(A,1)+blockbandwidth(A,2))))
-_qr(lay::AbstractBlockBandedLayout, ax::Tuple{AbstractUnitRange{Int},AbstractUnitRange{Int}}, A) = _qr(lay, map(length, ax), A)
+_qr(::AbstractBlockBandedLayout, _, A) = qr!(BlockBandedMatrix(A, (blockbandwidth(A,1), blockbandwidth(A,1)+blockbandwidth(A,2))))
 _ql(::AbstractBlockBandedLayout, _, A) = ql!(BlockBandedMatrix(A, (blockbandwidth(A,1)+blockbandwidth(A,2),blockbandwidth(A,2))))
 _factorize(::AbstractBlockBandedLayout, _, A) = qr(A)
 
-function materialize!(M::Lmul{<:AdjQRPackedQLayout{<:AbstractBlockBandedLayout}})
-    adjQ,Bin = M.A,M.B
+function lmul!(adjQ::Adjoint{<:Any,<:QRPackedQ{<:Any,<:BlockSkylineMatrix}}, Bin::AbstractVector)
     Q = parent(adjQ)
     A = Q.factors
     l,u = blockbandwidths(A)
@@ -91,7 +78,8 @@ function materialize!(M::Lmul{<:AdjQRPackedQLayout{<:AbstractBlockBandedLayout}}
     end
     Bin
 end
-function materialize!(M::Lmul{<:AdjQLPackedQLayout{<:AbstractBlockBandedLayout}})
+
+function lmul!(adjQ::Adjoint{<:Any,<:QLPackedQ{<:Any,<:BlockSkylineMatrix}}, Bin::AbstractVector)
     Q = parent(adjQ)
     A = Q.factors
     l,u = blockbandwidths(A)

src/broadcast.jl

@@ -46,7 +46,7 @@ similar(bc::Broadcasted{<:AbstractBlockBandedStyle}, ::Type{T}) where T =
 
 checkblocks(A, B) = blockisequal(axes(A), axes(B)) || throw(DimensionMismatch("*"))
 
-function _blockbanded_copyto!(dest::AbstractMatrix, src::AbstractMatrix)
+function _blockbanded_copyto!(dest::AbstractMatrix{T}, src::AbstractMatrix) where T
     @boundscheck checkblocks(dest, src)
 
     dl, du = colblockbandwidths(dest)
@@ -57,13 +57,13 @@ function _blockbanded_copyto!(dest::AbstractMatrix, src::AbstractMatrix)
 
     for J = 1:N
         for K = max(1,J-du[J]):min(J-su[J]-1,M)
-            zero!(view(dest,Block(K),Block(J)))
+            view(dest,Block(K),Block(J)) .= zero(T)
         end
         for K = max(1,J-su[J]):min(J+sl[J],M)
-            copyto!(view(dest,Block(K),Block(J)), view(src,Block(K),Block(J)))
+            view(dest,Block(K),Block(J)) .= view(src,Block(K),Block(J))
         end
         for K = max(1,J+sl[J]+1):min(J+dl[J],M)
-            zero!(dest,Block(K),Block(J))
+            view(dest,Block(K),Block(J)) .= zero(T)
         end
     end
     dest

src/linalg.jl

@@ -77,9 +77,8 @@ function blockbandwidths(V::SubBlockSkylineMatrix{<:Any,LL,UU,BlockRange1,BlockR
     KR = parentindices(V)[1].block.indices[1]
     JR = parentindices(V)[2].block.indices[1]
 
-    shift =  first(KR) - first(JR)
-    l,u = blockbandwidths(A)
-    l-shift, u+shift
+    @assert KR[1] == JR[1] == 1
+    blockbandwidths(A)
 end