Change PseudoBlockArray to BlockedArray

Author: jishnub

src/Caching/bandedblockbanded.jl

@@ -24,9 +24,9 @@ function resizedata!(B::CachedOperator{T,<:BandedBlockBandedMatrix{T}}, ::Colon,
         rows = blocklengths(rangespace(B.op))[1:J+l]
         cols = blocklengths(domainspace(B.op))[1:J]
 
-        # B.data = _BandedBlockBandedMatrix(PseudoBlockArray
+        # B.data = _BandedBlockBandedMatrix(BlockedArray
 
-        blocks = PseudoBlockArray(pad(B.data.data.blocks,:,(l+u+1)*sum(cols)), (axes(B.data.data,1), blockedrange(cols)))
+        blocks = BlockedArray(pad(B.data.data.blocks,:,(l+u+1)*sum(cols)), (axes(B.data.data,1), blockedrange(cols)))
         B.data = _BandedBlockBandedMatrix(blocks, rows, cols, (l, u), (λ, μ))
 
         jr=B.datasize[2]+1:col

src/LinearAlgebra/helper.jl

@@ -388,17 +388,17 @@ function interlace(a::AbstractVector, b::AbstractVector, (ncomponents_a, ncompon
     pad_b = pad(b, ncomponents_b * nblk_b)
 
     blksz_a = Fill(ncomponents_a, nblk_a)
-    aPBlk = PseudoBlockArray(pad_a, blksz_a)
+    aPBlk = BlockedArray(pad_a, blksz_a)
     blksz_b = Fill(ncomponents_b, nblk_b)
-    bPBkl = PseudoBlockArray(pad_b, blksz_b)
+    bPBkl = BlockedArray(pad_b, blksz_b)
 
     nblk_ret = nblk_a + nblk_b
     blksz_ret = zeros(Int, nblk_ret)
     blksz_ret[1:2:end] = blksz_a
     blksz_ret[2:2:end] = blksz_b
     nret = sum(blksz_ret)
     ret = initvector(T, nret)
-    retPBlk = PseudoBlockArray(ret, blksz_ret)
+    retPBlk = BlockedArray(ret, blksz_ret)
 
     @views begin
         for (ind, i) in enumerate(1:2:nblk_ret)

src/Operators/Operator.jl

@@ -687,9 +687,9 @@ macro wrappergetindex(Wrap)
                 ApproxFunBase.default_BlockBandedMatrix)
         end
 
-        function ApproxFunBase.PseudoBlockMatrix(S::ApproxFunBase.SubOperator{T,OP}) where {T,OP<:$Wrap}
+        function ApproxFunBase.BlockedMatrix(S::ApproxFunBase.SubOperator{T,OP}) where {T,OP<:$Wrap}
             ApproxFunBase._blockmaybebandedmatrix(S,
-                ApproxFunBase.PseudoBlockMatrix,
+                ApproxFunBase.BlockedMatrix,
                 ApproxFunBase.default_BlockMatrix)
         end
 
@@ -886,18 +886,18 @@ function BlockBandedMatrix(S::Operator)
 end
 
 function default_BlockMatrix(S::Operator)
-    ret = PseudoBlockArray(zeros(eltype(S), size(S)),
+    ret = BlockedArray(zeros(eltype(S), size(S)),
                         AbstractVector{Int}(blocklengths(rangespace(S))),
                         AbstractVector{Int}(blocklengths(domainspace(S))))
     ret .= S
     ret
 end
 
-function PseudoBlockMatrix(S::Operator)
+function BlockedMatrix(S::Operator)
     if isbandedblockbanded(S)
-        PseudoBlockMatrix(BandedBlockBandedMatrix(S))
+        BlockedMatrix(BandedBlockBandedMatrix(S))
     elseif isblockbanded(S)
-        PseudoBlockMatrix(BlockBandedMatrix(S))
+        BlockedMatrix(BlockBandedMatrix(S))
     else
         default_BlockMatrix(S)
     end
@@ -937,7 +937,7 @@ function arraytype(V::SubOperator{T,B,Tuple{KR,JR}}) where {T, B, KR <: Union{Bl
     P = parent(V)
     isbandedblockbanded(P) && return BandedBlockBandedMatrix
     isblockbanded(P) && return BlockBandedMatrix
-    return PseudoBlockMatrix
+    return BlockedMatrix
 end
 
 function arraytype(V::SubOperator{T,B,Tuple{KR,JR}}) where {T, B, KR <: Block, JR <: Block}