only copy non-zero blocks

Author: dlfivefifty

src/BlockArrays.jl

@@ -26,7 +26,7 @@ import Base: @propagate_inbounds, Array, to_indices, to_index,
             broadcast, eltype, convert, similar,
             @_inline_meta, tail, @_propagate_inbounds_meta, reindex,
             RangeIndex, Int, Integer, Number,
-            +, -, *, /, \, min, max, isless, in, copy, copyto!, axes, @deprecate,
+            +, -, *, /, \, ==, min, max, isless, in, copy, copyto!, axes, @deprecate,
             BroadcastStyle, checkbounds, throw_boundserror,
             ones, zeros, intersect, Slice, resize!
 using Base: ReshapedArray, dataids

src/blocklinalg.jl

@@ -123,9 +123,15 @@ function _copyto!(_, ::AbstractBlockLayout, dest::AbstractVector, src::AbstractV
         return dest
     end
 
-    @inbounds for K = blockaxes(src,1)
+    @inbounds for K = blockcolsupport(src)
         copyto!(view(dest,K), view(src,K))
     end
+    @inbounds for K = blockcolsupport(dest)
+        if K ∉ blockcolsupport(src)
+            zero!(view(dest,K))
+        end
+    end
+
     dest
 end
 

src/pseudo_blockarray.jl

@@ -129,10 +129,11 @@ convert(::Type{AbstractArray}, A::PseudoBlockArray) = A
 
 
 
-PseudoBlockArray{T, N}(A::AbstractArray{T2, N}) where {T,T2,N} =
-    PseudoBlockArray(Array{T, N}(A), axes(A))
+PseudoBlockArray{T, N}(A::AbstractArray{T2, N}) where {T,T2,N} = copyto!(PseudoBlockArray{T,N}(undef, axes(A)), A)
 PseudoBlockArray{T1}(A::AbstractArray{T2, N}) where {T1,T2,N} = PseudoBlockArray{T1, N}(A)
 PseudoBlockArray(A::AbstractArray{T, N}) where {T,N} = PseudoBlockArray{T, N}(A)
+PseudoBlockVector(A::AbstractVector{T}) where T = PseudoBlockVector{T}(A)
+PseudoBlockMatrix(A::AbstractMatrix{T}) where T = PseudoBlockMatrix{T}(A)
 
 convert(::Type{PseudoBlockArray{T, N}}, A::AbstractArray{T2, N}) where {T,T2,N} =
     PseudoBlockArray(convert(Array{T, N}, A), axes(A))
@@ -145,6 +146,7 @@ AbstractArray{T}(A::PseudoBlockArray) where T = PseudoBlockArray(AbstractArray{T
 AbstractArray{T,N}(A::PseudoBlockArray) where {T,N} = PseudoBlockArray(AbstractArray{T,N}(A.blocks), A.axes)
 
 copy(A::PseudoBlockArray) = PseudoBlockArray(copy(A.blocks), A.axes)
+==(A::PseudoBlockArray, B::PseudoBlockArray) = A.blocks == B.blocks
 
 ###########################
 # AbstractArray Interface #