fix whitespace

Author: jishnub

examples/blockarray_backend.jl

@@ -22,7 +22,7 @@ import LinearAlgebra
 # BlockArrays
 adapt(T::Type{<:AbstractArray}, b::BlockArray) =
     _BlockArray(T.(b.blocks), b.block_sizes)
-adapt(T::Type{<:AbstractArray}, b::PseudoBlockArray) = 
+adapt(T::Type{<:AbstractArray}, b::PseudoBlockArray) =
     PseudoBlockArray(T(b.blocks), b.block_sizes)
 adapt(T::Type{<:PseudoBlockArray}, b::BlockArray) = T(b.blocks, b.block_sizes)
 adapt(T::Type{<:BlockArray}, b::PseudoBlockArray) = T(b.blocks, b.block_sizes)
@@ -115,7 +115,7 @@ function banded_mul!(c::BlockVector{T},
 
     @inbounds for i = 1:N, j = max(1,i-l):min(M,i+u)
       B = _BandedMatrix(A.data.blocks[i - j + u + 1, j],
-                        size(view(A, Block(i, j)), 1), 
+                        size(view(A, Block(i, j)), 1),
                         λ, μ)
         muladd!(one(T), B, x.blocks[j], one(T), c[Block(i)])
     end
@@ -149,7 +149,7 @@ function testme()
         @test eltype(cu(bmat)) === Float32
       end
     end
-   
+
     @testset "PseudoBlockArray Adapters" begin
       bmat = BandedBlockBandedMatrix{Float64}(undef, ([1, 1], [2, 2]), (1, 2), (1, 1))
       @test adapt(JLArray, bmat) isa BandedBlockBandedMatrix
@@ -175,7 +175,7 @@ function testme()
        x = PseudoBlockArray(Array{Float64, 1}(undef, size(A, 2)), m)
        x .= rand.()
        xblock = adapt(BlockArray, x)
-   
+
        @test LinearAlgebra.mul!(cblock, Ablock, xblock) ≈ A * x
        cblock .= 0
        @test banded_mul!(cblock, Ablock, xblock) ≈ A * x
@@ -201,7 +201,7 @@ function benchmarks()
   for N in [10, 100, 500, 1000], n = [N ÷ 5, N, 5N, 10N]
     l, u, λ, μ = rand(0:2, 4)
     M, m = N, n
-  
+
     A = BandedBlockBandedMatrix{Float64}(
              undef, (repeat([n], N), repeat([m], M)), (l, u), (λ, μ))
     A.data .= rand.()
@@ -233,7 +233,7 @@ function benchmarks()
   suite
 end
 
-block_ratio(result, name; method=median) = 
+block_ratio(result, name; method=median) =
     ratio(method(result["block"][name]), method(result["pseudo"][name]))
-viabm_ratio(result, name; method=median) = 
+viabm_ratio(result, name; method=median) =
     ratio(method(result["viabm"][name]), method(result["block"][name]))

src/AbstractBlockBandedMatrix.jl

@@ -149,9 +149,9 @@ end
 
 @inline function blockbanded_colstart(A, i::Integer)
     bs = blockcolstart(A,findblock(axes(A,2),i))
-    if isempty(axes(A,1)) 
+    if isempty(axes(A,1))
         1
-    elseif Int(bs) ≤ blocksize(A, 2)
+    elseif Int(bs) ≤ blocksize(A, 2)
         first(axes(A,1)[bs])
     else
         size(A,1)+1
@@ -170,7 +170,7 @@ end
 @inline function blockbanded_rowstop(A, i::Integer)
     CS = blockrowstop(A,findblock(axes(A,1),i))
     CS == Block(0) && return 0
-    last(axes(A,2)[CS])    
+    last(axes(A,2)[CS])
 end
 
 @inline blockbanded_colsupport(A, j::Integer) = blockbanded_colstart(A, j):blockbanded_colstop(A, j)
@@ -200,5 +200,5 @@ function ==(A::AbstractBlockBandedMatrix, B::AbstractBlockBandedMatrix)
     for J = blockaxes(A,2), K = max(Block(1),J-u):min(J+l,Block(N))
         view(A, K, J) == view(B, K, J) || return false
     end
-    return true 
-end
+    return true
+end

src/BandedBlockBandedMatrix.jl

@@ -1,5 +1,5 @@
 function check_data_sizes(data::AbstractMatrix, raxis, (l,u), (λ,μ))
-    if blocksize(data,1) ≠ l + u + 1 && !(blocksize(data,1) == 0 && (-l > u || -λ > μ))
+    if blocksize(data,1) ≠ l + u + 1 && !(blocksize(data,1) == 0 && (-l > u || -λ > μ))
         throw(ArgumentError("Data matrix must have number of row blocks equal to number of block bands"))
     end
     for K = blockaxes(data,1)
@@ -60,9 +60,9 @@ BandedBlockBandedMatrix{T,B}(::UndefInitializer, axes::NTuple{2,AbstractUnitRang
 BandedBlockBandedMatrix{T,B}(::UndefInitializer, rblocksizes::AbstractVector{Int}, cblocksizes::AbstractVector{Int}, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) where {T,B} =
     BandedBlockBandedMatrix{T,B}(undef, (blockedrange(rblocksizes),blockedrange(cblocksizes)), lu, λμ)
 
-BandedBlockBandedMatrix{T}(::UndefInitializer, axes::NTuple{2,AbstractUnitRange{Int}}, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) where T = 
+BandedBlockBandedMatrix{T}(::UndefInitializer, axes::NTuple{2,AbstractUnitRange{Int}}, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) where T =
     _BandedBlockBandedMatrix(PseudoBlockMatrix{T}(undef, _bbb_data_axes(axes[2],lu,λμ)), axes[1], lu, λμ)
-BandedBlockBandedMatrix{T}(::UndefInitializer, rblocksizes::AbstractVector{Int}, cblocksizes::AbstractVector{Int}, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) where T = 
+BandedBlockBandedMatrix{T}(::UndefInitializer, rblocksizes::AbstractVector{Int}, cblocksizes::AbstractVector{Int}, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) where T =
     BandedBlockBandedMatrix{T}(undef, (blockedrange(rblocksizes),blockedrange(cblocksizes)), lu, λμ)
 
 
@@ -210,7 +210,7 @@ function BandedBlockBandedMatrix{T,Blocks,RR}(A::AbstractMatrix, axes::NTuple{2,
     ret
 end
 
-BandedBlockBandedMatrix{T}(A::AbstractMatrix, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) where T = 
+BandedBlockBandedMatrix{T}(A::AbstractMatrix, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) where T =
     copyto!(BandedBlockBandedMatrix{T}(undef, axes(A), lu, λμ), A)
 BandedBlockBandedMatrix{T}(A::AbstractMatrix) where T = BandedBlockBandedMatrix{T}(A, blockbandwidths(A), subblockbandwidths(A))
 
@@ -354,7 +354,7 @@ end
 @inline function setindex!(A::BandedBlockBandedMatrix{T}, v, i::Int, j::Int) where T
     @boundscheck checkbounds(A, i, j)
     BI,BJ = findblockindex.(axes(A), (i,j))
-    if -A.l ≤ Int(block(BJ)-block(BI)) ≤ A.u
+    if -A.l ≤ Int(block(BJ)-block(BI)) ≤ A.u
         V = view(A, block(BI),block(BJ))
          @inbounds V[blockindex(BI),blockindex(BJ)] = convert(T, v)::T
     elseif !iszero(v)
@@ -370,7 +370,7 @@ function layout_replace_in_print_matrix(::AbstractBandedBlockBandedLayout, A, i,
     i,j = blockindex.(bi)
     l,u = blockbandwidths(A)
     λ,μ = subblockbandwidths(A)
-    -l ≤ Int(J-I) ≤ u && -λ ≤ j-i ≤ μ ? s : Base.replace_with_centered_mark(s)
+    -l ≤ Int(J-I) ≤ u && -λ ≤ j-i ≤ μ ? s : Base.replace_with_centered_mark(s)
 end
 
 
@@ -422,7 +422,7 @@ sublayout(::BandedBlockBandedColumns{ML}, ::Type{II}) where {ML,II<:Tuple{BlockS
 blockbandshift(A::BlockSlice, B::BlockSlice) = BandedMatrices.bandshift(Int.(A.block), Int.(B.block))
 blockbandshift(S) = blockbandshift(parentindices(S)[1],parentindices(S)[2])
 
-function bandedblockbandeddata(V::SubArray) 
+function bandedblockbandeddata(V::SubArray)
     l,u = blockbandwidths(V)
     L,U = blockbandwidths(parent(V)) .+ (-1,1) .* blockbandshift(V)
     view(bandedblockbandeddata(parent(V)), Block.(U-u+1:U+l+1), parentindices(V)[2])
@@ -493,7 +493,7 @@ function inblockbands(V::SubArray{<:Any,2,<:AbstractMatrix,<:Tuple{BlockSlice1,B
     K_sl, J_sl = parentindices(V)
     K, J = K_sl.block, J_sl.block
     l,u = blockbandwidths(A)
-    -l ≤ Int(J-K) ≤ u
+    -l ≤ Int(J-K) ≤ u
 end
 
 function parentblock(V::SubArray{T,2,<:AbstractMatrix,<:Tuple{BlockSlice{<:BlockIndexRange1},BlockSlice{<:BlockIndexRange1}}}) where T
@@ -514,7 +514,7 @@ function parentblock(V::SubArray{T,2,<:AbstractMatrix,<:Tuple{BlockSlice{<:Block
     view(A, K_sl.block.block, J_sl.block)
 end
 
-# gives the columns of parent(V).data that encode the block
+# gives the columns of parent(V).data that encode the block
 parentblocks2Int(V::BandedBlockBandedBlock)::Tuple{Int,Int} = Int(first(parentindices(V)).block),
                                                           Int(last(parentindices(V)).block)
 
@@ -592,7 +592,7 @@ end
     @boundscheck checkbounds(V, k, j)
     A = parent(V)
     K,J = parentblocks2Int(V)
-    if -A.l ≤ J-K ≤ A.u && -A.λ ≤ j-k ≤ A.μ
+    if -A.l ≤ J-K ≤ A.u && -A.λ ≤ j-k ≤ A.μ
         inbands_getindex(V, k, j)
     else
         zero(eltype(V))
@@ -603,7 +603,7 @@ end
     @boundscheck checkbounds(V, k, j)
     A = parent(V)
     K,J = parentblocks2Int(V)
-    if -A.l ≤ J-K ≤ A.u && -A.λ ≤ j-k ≤ A.μ
+    if -A.l ≤ J-K ≤ A.u && -A.λ ≤ j-k ≤ A.μ
         inbands_setindex!(V, v, k, j)
     elseif iszero(v) # allow setindex for 0 datya
         v

src/BlockSkylineMatrix.jl

@@ -218,15 +218,15 @@ BlockBandedMatrix{T}(A::AbstractMatrix, block_sizes::BlockBandedSizes) where T =
 ##
 
 function BlockSkylineMatrix{T}(Z::Zeros, block_sizes::BlockSkylineSizes) where T
-    if size(Z) ≠ map(length,block_sizes.axes)
+    if size(Z) ≠ map(length,block_sizes.axes)
         throw(DimensionMismatch("Size of input $(size(Z)) must be consistent with $(size(block_sizes))"))
     end
     _BlockSkylineMatrix(zeros(T, bb_numentries(block_sizes)), block_sizes)
 end
 
 
 function BlockSkylineMatrix{T}(E::Eye, block_sizes::BlockSkylineSizes) where T
-    if size(E) ≠ size(block_sizes)
+    if size(E) ≠ size(block_sizes)
         throw(DimensionMismatch("Size of input $(size(E)) must be consistent with $(sum.(dims))"))
     end
     ret = BlockSkylineMatrix(Zeros{T}(size(E)), block_sizes)
@@ -364,7 +364,7 @@ const BlockBandedBlock{T} = SubArray{T,2,<:BlockSkylineMatrix,<:Tuple{BlockSlice
 
 
 
-# gives the columns of parent(V).data that encode the block
+# gives the columns of parent(V).data that encode the block
 _parent_blocks(V::BlockBandedBlock)::Tuple{Int,Int} =
     first(first(parentindices(V)).block.n),first(last(parentindices(V)).block.n)
 
@@ -388,7 +388,7 @@ strides(V::BlockBandedBlock) = (1,parent(V).block_sizes.block_strides[_parent_bl
     @boundscheck checkbounds(V, k, j)
     A = parent(V)
     K,J = _parent_blocks(V)
-    if -A.block_sizes.l[J] ≤ J-K ≤ A.block_sizes.u[J]
+    if -A.block_sizes.l[J] ≤ J-K ≤ A.block_sizes.u[J]
         b_start = blockstart(A,K,J)
         b_start == 0 && return zero(eltype(V))
         b_stride = blockstride(A,J)
@@ -402,7 +402,7 @@ end
     @boundscheck checkbounds(V, k, j)
     A = parent(V)
     K,J = _parent_blocks(V)
-    if -A.block_sizes.l[J] ≤ J-K ≤ A.block_sizes.u[J]
+    if -A.block_sizes.l[J] ≤ J-K ≤ A.block_sizes.u[J]
         b_start = blockstart(A,K,J)
         # TODO: What to do if b_start == 0 ?
         b_stride = A.block_sizes.block_strides[J]

src/adjtransblockbanded.jl

@@ -4,4 +4,4 @@ subblockbandwidths(A::AdjOrTrans) = reverse(subblockbandwidths(parent(A)))
 transposelayout(::AbstractBlockBandedLayout) = BlockBandedLayout()
 transposelayout(::AbstractBandedBlockBandedLayout) = BandedBlockBandedLayout()
 conjlayout(::Type{<:Complex}, ::M) where M<:AbstractBandedBlockBandedLayout = ConjLayout{M}()
-conjlayout(::Type{<:Complex}, ::M) where M<:AbstractBlockBandedLayout = ConjLayout{M}()
+conjlayout(::Type{<:Complex}, ::M) where M<:AbstractBlockBandedLayout = ConjLayout{M}()

src/blockskylineqr.jl

@@ -36,7 +36,7 @@ function _blockbanded_qr!(A::AbstractMatrix, τ::AbstractVector, NCOLS::Block{1}
     A,τ
 end
 
-function qr!(A::BlockBandedMatrix{T}) where T 
+function qr!(A::BlockBandedMatrix{T}) where T
     M,N = blocksize(A)
     ax1 = M < N ? axes(A,1) : axes(A,2)
     _blockbanded_qr!(A, PseudoBlockVector(zeros(T,length(ax1)), (ax1,)))
@@ -52,7 +52,7 @@ function ql!(A::BlockBandedMatrix{T}) where T
         axes(A,2)
     end
     τ = PseudoBlockVector{T}(undef, (ax2,))
-    
+
     for K = N:-1:max(N - M + 1,1)
         μ = M+K-N
         KR = Block.(max(K-u,1):μ)
@@ -126,7 +126,7 @@ function materialize!(Mul::MatLmulMat{<:AdjQRPackedQLayout{<:AbstractBlockBanded
     Bin
 end
 
-# avoid LinearALgebra Strided obsession 
+# avoid LinearALgebra Strided obsession
 
 for Typ in (:StridedVector, :StridedMatrix, :AbstractVector, :AbstractMatrix, :LayoutMatrix, :LayoutVector)
     @eval function ldiv!(A::QR{<:Any,<:BlockSkylineMatrix}, B::$Typ)

src/broadcast.jl

@@ -2,7 +2,7 @@
 # Here we override broadcasting for banded matrices.
 # The design is to to exploit the broadcast machinery so that
 # banded matrices that conform to the banded matrix interface but are not
-# <: AbstractBandedMatrix can get access to fast copyto!, lmul!, rmul!, axpy!, etc.
+# <: AbstractBandedMatrix can get access to fast copyto!, lmul!, rmul!, axpy!, etc.
 # using broadcast variants (B .= A, B .= 2.0 .* A, etc.)
 
 
@@ -43,7 +43,7 @@ _blockbandwidth_l(l, a, ax) = blockisequal(axes(a,2),ax) ? (l,blockbandwidth(a,2
 _broadcast_blockbandwidths(bnds, _, _) = bnds
 _broadcast_blockbandwidths((l,u), a::AbstractVector, (ax1,ax2)) =
     _blockbandwidth_u(u, a, ax1)
-    
+
 
 function _broadcast_blockbandwidths((l,u), A::AbstractArray, (ax1,ax2))
     if size(A,2) == 1
@@ -70,8 +70,8 @@ _broadcast_subblockbandwidths(bnds) = bnds
 _broadcast_subblockbandwidths(bnds, _) = bnds
 _broadcast_subblockbandwidths((l,u), a::AbstractVector) = (bandwidth(a,1),u)
 
-function _broadcast_subblockbandwidths((l,u), A::AbstractArray) 
-    size(A,2) == 1 && return (subblockbandwidth(A,1),u) 
+function _broadcast_subblockbandwidths((l,u), A::AbstractArray)
+    size(A,2) == 1 && return (subblockbandwidth(A,1),u)
     size(A,1) == 1 && return (l, subblockbandwidth(A,2))
     subblockbandwidths(A) # need to special case vector broadcasting
 end
@@ -355,7 +355,7 @@ for op in (:+, :-)
     @eval function copyto!(C::AbstractArray{T}, bc::Broadcasted{<:AbstractBlockBandedStyle, <:Any, typeof($op),
                                                                 <:Tuple{<:AbstractMatrix,<:AbstractMatrix}}) where T
         bc_axes = Base.Broadcast.combine_axes(bc.args...)# Use combine_axes as `bc` might get axes from `C`
-        if !blockisequal(axes(C), bc_axes) 
+        if !blockisequal(axes(C), bc_axes)
             copyto!(PseudoBlockArray(C, bc_axes), bc)
             return C
         end

src/interfaceimpl.jl

@@ -71,7 +71,7 @@ isblockbanded(A::BlockArray) = isbanded(A.blocks)
     K,J = KJ.n
     @boundscheck blockcheckbounds(block_arr, K, J)
     l,u = blockbandwidths(block_arr)
-    -l ≤ (J-K) ≤ u || return convert(VT, Zeros{T}(length.(getindex.(axes(block_arr),(Block(K),Block(J))))...))
+    -l ≤ (J-K) ≤ u || return convert(VT, Zeros{T}(length.(getindex.(axes(block_arr),(Block(K),Block(J))))...))
     block_arr.blocks[K,J]
 end
 
@@ -97,14 +97,14 @@ for op in (:-, :+)
 
         function $op(A::BlockTridiagonal, λ::UniformScaling)
             checksquareblocks(A)
-            mortar(Tridiagonal(broadcast($op, A.blocks.dl, Ref(0λ)), 
+            mortar(Tridiagonal(broadcast($op, A.blocks.dl, Ref(0λ)),
                                broadcast($op, A.blocks.d, Ref(λ)),
                                broadcast($op, A.blocks.du, Ref(0λ))))
         end
         function $op(λ::UniformScaling, A::BlockTridiagonal)
             checksquareblocks(A)
-            mortar(Tridiagonal(broadcast($op, Ref(0λ), A.blocks.dl), 
-                               broadcast($op, Ref(λ), A.blocks.d), 
+            mortar(Tridiagonal(broadcast($op, Ref(0λ), A.blocks.dl),
+                               broadcast($op, Ref(λ), A.blocks.d),
                                broadcast($op, Ref(0λ), A.blocks.du)))
         end
         function $op(A::BlockBidiagonal, λ::UniformScaling)
@@ -167,7 +167,6 @@ sub_materialize(::AbstractBandedLayout, V, ::Tuple{BlockedUnitRange,Base.OneTo{I
 sub_materialize(::AbstractBandedLayout, V, ::Tuple{Base.OneTo{Int},BlockedUnitRange}) = BandedMatrix(V)
 
 
-
 #####
 # BlockKron
 #####
@@ -177,4 +176,4 @@ isbandedblockbanded(K::BlockKron) = all(isbanded, K.args)
 blockbandwidths(K::BlockKron) = bandwidths(first(K.args))
 subblockbandwidths(K::BlockKron) = bandwidths(last(K.args))
 
-_blockkron(::Tuple{Vararg{AbstractBandedLayout}}, A) = BandedBlockBandedMatrix(BlockKron(A...))
+_blockkron(::Tuple{Vararg{AbstractBandedLayout}}, A) = BandedBlockBandedMatrix(BlockKron(A...))

src/triblockbanded.jl

@@ -7,15 +7,15 @@ isblockbanded(A::AbstractTriangular) =
     isblockbanded(parent(A))
 isbandedblockbanded(A::AbstractTriangular) =
     isbandedblockbanded(parent(A))
-function blockbandwidths(A::Union{UpperTriangular,UnitUpperTriangular}) 
+function blockbandwidths(A::Union{UpperTriangular,UnitUpperTriangular})
     P = parent(A)
     if hasmatchingblocks(P)
         (min(0,blockbandwidth(P,1)), blockbandwidth(P,2))
     else
         blockbandwidths(P)
     end
 end
-function blockbandwidths(A::Union{LowerTriangular,UnitLowerTriangular}) 
+function blockbandwidths(A::Union{LowerTriangular,UnitLowerTriangular})
     P = parent(A)
     if hasmatchingblocks(P)
         (blockbandwidth(P,1), min(0,blockbandwidth(P,2)))

test/test_bandedblockbanded.jl

@@ -524,7 +524,7 @@ import ArrayLayouts: RangeCumsum
         cols = rows = 1:N
         data = reshape(collect(1:(λ+μ+1)*(l+u+1)*sum(cols)), ((λ + μ + 1) * (l + u + 1), sum(cols)))
         A = _BandedBlockBandedMatrix(data, rows, cols, (l, u), (λ, μ))
-        
+
         @test blockbandwidths(Hermitian(A)) == blockbandwidths(Symmetric(A)) == (1,1)
         @test blockbandwidths(Hermitian(A,:L)) == blockbandwidths(Symmetric(A,:L)) == (2,2)
         @test subblockbandwidths(Hermitian(A)) == subblockbandwidths(Symmetric(A)) == (2,2)

test/test_blockbanded.jl

@@ -96,7 +96,7 @@ import Base.Broadcast: materialize!
         cols = rows = 1:N
         A = BlockBandedMatrix{Int}(undef, rows,cols, (l,u))
         A.data .= 1:length(A.data)
-        
+
         @test @inferred(blockrowsupport(A, Block(1))) == Block.(1:3)
         @test blockrowsupport(A, Block(2)) == Block.(1:4)
         @test blockrowsupport(A, Block(3)) == Block.(2:4)
@@ -108,7 +108,7 @@ import Base.Broadcast: materialize!
 
         @test @inferred(blockrowsupport(A, Block.(3:4))) == Block.(2:4)
         @test @inferred(blockcolsupport(A, Block.(1:2))) == Block.(1:3)
-        
+
         @test @inferred(blockcolsupport(A, Block.(1:0))) == Block.(1:0)
     end
 
@@ -220,4 +220,4 @@ import Base.Broadcast: materialize!
         f(s) = s.block_starts.data
         @inferred(f(s))
     end
-end
+end

test/test_blockskylineqr.jl

@@ -175,7 +175,7 @@ import BlockBandedMatrices: blockcolsupport
 
         b = [1; zeros(size(T,1)-1)]
         B = [Matrix(I,2,2); zeros(size(T,1)-2,2)]
-        @test ((T - z*I)\b)[1] ≈ (F\b)[1] ≈ (F \ B)[1,1] ≈ ((T - z*I)\B)[1,1] ≈ -0.1309123477325813 + 0.28471699370329884im 
+        @test ((T - z*I)\b)[1] ≈ (F\b)[1] ≈ (F \ B)[1,1] ≈ ((T - z*I)\B)[1,1] ≈ -0.1309123477325813 + 0.28471699370329884im
     end
 
     @testset "BigFloat QR" begin