PseudoBlock -> Blocked

Author: dlfivefifty

src/banded/infbanded.jl

@@ -385,7 +385,7 @@ sub_materialize(_, V, ::Tuple{BlockedOneTo{Int,<:InfRanges}}) = V
 sub_materialize(::AbstractBlockLayout, V, ::Tuple{BlockedOneTo{Int,<:InfRanges}}) = V
 function sub_materialize(::PaddedColumns, v::AbstractVector{T}, ax::Tuple{BlockedOneTo{Int,<:InfRanges}}) where T
     dat = paddeddata(v)
-    PseudoBlockVector(Vcat(sub_materialize(dat), Zeros{T}(∞)), ax)
+    BlockedVector(Vcat(sub_materialize(dat), Zeros{T}(∞)), ax)
 end
 
 ##

src/blockbanded/blockbanded.jl

@@ -68,9 +68,9 @@ BroadcastStyle(::Type{<:SubArray{T,N,Arr,<:NTuple{N,BlockSlice{BlockRange{1,Tupl
 
 # TODO: generalise following
 BroadcastStyle(::Type{<:BlockArray{T,N,<:AbstractArray{<:AbstractArray{T,N},N},<:NTuple{N,BlockedOneTo{Int,<:InfRanges}}}}) where {T,N} = LazyArrayStyle{N}()
-# BroadcastStyle(::Type{<:PseudoBlockArray{T,N,<:AbstractArray{T,N},<:NTuple{N,BlockedOneTo{Int,<:InfRanges}}}}) where {T,N} = LazyArrayStyle{N}()
+# BroadcastStyle(::Type{<:BlockedArray{T,N,<:AbstractArray{T,N},<:NTuple{N,BlockedOneTo{Int,<:InfRanges}}}}) where {T,N} = LazyArrayStyle{N}()
 BroadcastStyle(::Type{<:BlockArray{T,N,<:AbstractArray{<:AbstractArray{T,N},N},<:NTuple{N,BlockedOneTo{Int,<:RangeCumsum{Int,<:InfRanges}}}}}) where {T,N} = LazyArrayStyle{N}()
-# BroadcastStyle(::Type{<:PseudoBlockArray{T,N,<:AbstractArray{T,N},<:NTuple{N,BlockedOneTo{Int,<:RangeCumsum{Int,<:InfRanges}}}}}) where {T,N} = LazyArrayStyle{N}()
+# BroadcastStyle(::Type{<:BlockedArray{T,N,<:AbstractArray{T,N},<:NTuple{N,BlockedOneTo{Int,<:RangeCumsum{Int,<:InfRanges}}}}}) where {T,N} = LazyArrayStyle{N}()
 
 
 ###

src/infql.jl

@@ -174,7 +174,7 @@ function blocktailiterate(c,a,b, d=c, e=a)
         d̃,ẽ = QLPackedQ(F.factors[1:n,n+1:2n],F.τ[1:n])*d̃,QLPackedQ(F.factors[1:n,n+1:2n],F.τ[1:n])*ẽ  # undo last rotation
         if ≈(d̃, d; atol=1E-10) && ≈(ẽ, e; atol=1E-10)
             X[1:n,1:n] = d̃; X[1:n,n+1:2n] = ẽ
-            return PseudoBlockArray(X,fill(n,2), fill(n,3)), F.τ[n+1:2n]
+            return BlockedArray(X,fill(n,2), fill(n,3)), F.τ[n+1:2n]
         end
         d,e = d̃,ẽ
     end

src/infqr.jl

@@ -78,7 +78,7 @@ function partialqr!(F::AdaptiveQRData{<:Any,<:BlockSkylineMatrix}, N::Block{1})
             zero!(τ)
         else
             factors = view(F.data.data,Ñ+1:N+l,Ñ+1:N+u);
-            _blockbanded_qr!(factors, PseudoBlockVector(τ, (axes(factors,2)[Block(1):(N-Ñ)],)), N-Ñ)
+            _blockbanded_qr!(factors, BlockedVector(τ, (axes(factors,2)[Block(1):(N-Ñ)],)), N-Ñ)
         end
         F.ncols = n
     end
@@ -197,7 +197,7 @@ function resizedata_chop!(v::CachedVector, tol)
     v
 end
 
-function resizedata_chop!(v::PseudoBlockVector, tol)
+function resizedata_chop!(v::BlockedVector, tol)
     c = paddeddata(v.blocks)
     n = length(c)
     k_tol = choplength(c, tol)
@@ -252,7 +252,7 @@ function materialize!(M::MatLmulVec{<:AdjQRPackedQLayout{<:AdaptiveLayout},<:Abs
     resizedata_chop!(B, tolerance)
 end
 
-function resizedata!(B::PseudoBlockVector, M::Block{1})
+function resizedata!(B::BlockedVector, M::Block{1})
     resizedata!(B.blocks, last(axes(B,1)[M]))
     B
 end
@@ -267,7 +267,7 @@ function materialize!(M::MatLmulVec{<:QRPackedQLayout{<:AdaptiveLayout{<:Abstrac
     A,B_in = M.A,M.B
     sB = length(paddeddata(B_in))
     ax1,ax2 = axes(A.factors.data.data)
-    B = PseudoBlockVector(B_in, (ax2,))
+    B = BlockedVector(B_in, (ax2,))
     SB = findblock(ax2, sB)
     partialqr!(A.factors.data,SB)
     JR = Block(1):SB
@@ -285,7 +285,7 @@ function materialize!(M::MatLmulVec{<:AdjQRPackedQLayout{<:AdaptiveLayout{<:Abst
     T = eltype(M)
     COLGROWTH = 300 # rate to grow columns
     ax1,ax2 = axes(A.factors.data.data)
-    B = PseudoBlockVector(B_in, (ax1,))
+    B = BlockedVector(B_in, (ax1,))
 
     SB = findblock(ax1, length(paddeddata(B_in)))
     MA, NA = blocksize(A.factors.data.data.array)
@@ -334,7 +334,7 @@ function ldiv!(R::UpperTriangular{<:Any,<:AdaptiveQRFactors}, B::CachedVector{<:
 end
 
 
-function ldiv!(R::UpperTriangular{<:Any,<:AdaptiveQRFactors}, B::PseudoBlockArray)
+function ldiv!(R::UpperTriangular{<:Any,<:AdaptiveQRFactors}, B::BlockedArray)
     n = B.blocks.datasize[1]
     N = findblock(axes(R,1),n)
     partialqr!(parent(R).data, N)

test/runtests.jl

@@ -29,7 +29,7 @@ end
     A = randn(5, 5)
     @test chop([A zeros(5, 2); zeros(2, 5) zeros(2, 2)], eps()) == A
 
-    c = PseudoBlockArray([randn(5); zeros(10)], (blockedrange(1:5),))
+    c = BlockedArray([randn(5); zeros(10)], (blockedrange(1:5),))
     d = chop!(c, 0)
     @test length(d) == 6
 
@@ -66,7 +66,7 @@ include("test_infbanded.jl")
 
         @test blockedrange(Vcat(2, Fill(3, ∞))) isa BlockedOneTo{<:Any,<:InfiniteArrays.InfStepRange}
 
-        c = PseudoBlockArray(1:∞, Vcat(2, Fill(3, ∞)))
+        c = BlockedArray(1:∞, Vcat(2, Fill(3, ∞)))
         @test c[Block.(2:∞)][Block.(2:10)] == c[Block.(3:11)]
 
         @test length(axes(b, 1)) ≡ ℵ₀
@@ -91,8 +91,8 @@ include("test_infbanded.jl")
     end
 
     @testset "padded" begin
-        c = PseudoBlockArray([1; zeros(∞)], Vcat(2, Fill(3, ∞)))
-        @test c + c isa PseudoBlockVector
+        c = BlockedArray([1; zeros(∞)], Vcat(2, Fill(3, ∞)))
+        @test c + c isa BlockedVector
     end
 
     @testset "concat" begin
@@ -174,7 +174,7 @@ include("test_infbanded.jl")
             @test axes(v) isa Tuple{BlockedOneTo{Int,ArrayLayouts.RangeCumsum{Int64,Base.OneTo{Int64}}}}
             @test @allocated(axes(v)) ≤ 40
 
-            dest = PseudoBlockArray{Float64}(undef, axes(v))
+            dest = BlockedArray{Float64}(undef, axes(v))
             @test copyto!(dest, v) == v
             @test @allocated(copyto!(dest, v)) ≤ 40
 
@@ -210,14 +210,14 @@ include("test_infbanded.jl")
             KR = Block.(Base.OneTo(N))
             V = view(dat, Block.(Base.OneTo(N)), :)
             @test MemoryLayout(V) isa LazyArrays.ApplyLayout{typeof(hcat)}
-            @test PseudoBlockArray(V)[Block.(1:5), :] == dat[Block.(1:5), :]
+            @test BlockedArray(V)[Block.(1:5), :] == dat[Block.(1:5), :]
             V = view(dat', :, Block.(Base.OneTo(N)))
             @test MemoryLayout(V) isa LazyArrays.ApplyLayout{typeof(vcat)}
             a = dat.arrays[1]'
             N = 100
             KR = Block.(Base.OneTo(N))
             v = view(a, :, KR)
-            @time r = PseudoBlockArray(v)
+            @time r = BlockedArray(v)
             @test v == r
         end
 
@@ -262,7 +262,7 @@ include("test_infbanded.jl")
     @testset "blockdiag" begin
         D = Diagonal(mortar(Fill.((-(0:∞) - (0:∞) .^ 2), 1:2:∞)))
         x = [randn(5); zeros(∞)]
-        x̃ = PseudoBlockArray(x, (axes(D, 1),))
+        x̃ = BlockedArray(x, (axes(D, 1),))
         @test (D*x)[1:10] == (D*x̃)[1:10]
     end
 

test/test_infqr.jl

@@ -275,7 +275,7 @@ import SemiseparableMatrices: AlmostBandedLayout, VcatAlmostBandedLayout
 
         x,y = 0.1,0.2
         θ,φ = acos(x),acos(y)
-        @test u[Block.(1:50)] isa PseudoBlockArray
+        @test u[Block.(1:50)] isa BlockedArray
         @test (sin.((1:50) .* φ)/sin(φ))' * InvDiagTrav(u[Block.(1:50)]) * sin.((1:50) .* θ)/sin(θ) ≈ 1/(x+y-4)
         @test (L*u)[1:10] ≈ [1; zeros(9)]