add some convenient functions (#11)

Author: KristofferC

src/blockarray.jl

@@ -13,7 +13,7 @@ can be very fast since no copying of data is needed.
 
 In the type definition, `R` defines the array type that each block has, for example `Matrix{Float64}.
 """
-immutable BlockArray{T, N, R} <: AbstractBlockArray{T, N}
+immutable BlockArray{T, N, R <: AbstractArray} <: AbstractBlockArray{T, N}
     blocks::Array{R, N}
     block_sizes::BlockSizes{N}
     function BlockArray(blocks::Array{R, N}, block_sizes::BlockSizes{N})
@@ -201,9 +201,29 @@ end
         @nloops $N i i->(1:length(block_sizes[i])) begin
             block_index = @ntuple $N i
             indices = globalrange(block_sizes, block_index)
-            arr[indices...] = block_array[Block(block_index...)]
+            arr[indices...] = getblock(block_array, block_index...)
         end
 
         return arr
     end
 end
+
+@generated function Base.copy!{T, N, R <: AbstractArray}(block_array::BlockArray{T, N, R}, arr::R)
+    return quote
+        block_sizes = block_array.block_sizes
+
+        @nloops $N i i->(1:length(block_sizes[i])) begin
+            block_index = @ntuple $N i
+            indices = globalrange(block_sizes, block_index)
+            copy!(getblock(block_array, block_index...), arr[indices...])
+        end
+
+        return block_array
+    end
+end
+
+function Base.fill!(block_array::BlockArray, v)
+    for block in block_array.blocks
+        fill!(block, v)
+    end
+end

src/pseudo_blockarray.jl

@@ -36,7 +36,7 @@ julia> A = PseudoBlockArray(sprand(6, 0.5), [3,2,1])
  0.0553841
 ```
 """
-immutable PseudoBlockArray{T, N, R} <: AbstractBlockArray{T, N}
+immutable PseudoBlockArray{T, N, R <: AbstractArray} <: AbstractBlockArray{T, N}
     blocks::R
     block_sizes::BlockSizes{N}
     function PseudoBlockArray(blocks::R, block_sizes::BlockSizes{N})
@@ -252,6 +252,14 @@ end
 # Misc #
 ########
 
-function Base.full{T,N,R}(block_array::PseudoBlockArray{T, N, R})
+function Base.full(block_array::PseudoBlockArray)
     return block_array.blocks
 end
+
+function Base.copy!{T, N, R <: AbstractArray}(block_array::PseudoBlockArray{T, N, R}, arr::R)
+    copy!(block_array.blocks, arr)
+end
+
+function Base.fill!(block_array::PseudoBlockArray, v)
+    fill!(block_array.blocks, v)
+end

test/runtests.jl

@@ -54,6 +54,11 @@ let
             getblock!(q2, BA_1, u)
             @test q2 == q
         end
+        fill!(BA_1, 1.0)
+        @test BA_1 == ones(size(BA_1))
+        ran = rand(size(BA_1))
+        copy!(BA_1, ran)
+        @test BA_1 == ran
 
         a_1_sparse = sprand(6, 0.9)
         BA_1_sparse = BlockType(a_1_sparse, [1,2,3])
@@ -83,6 +88,11 @@ let
             getblock!(q2, BA_2, u, γ)
             @test q2 == q
         end
+        fill!(BA_2, 1.0)
+        @test BA_2 == ones(size(BA_2))
+        ran = rand(size(BA_2))
+        copy!(BA_2, ran)
+        @test BA_2 == ran
 
         a_2_sparse = sprand(3, 7, 0.9)
         BA_2_sparse = BlockType(a_2_sparse, [1,2], [3,4])
@@ -111,7 +121,11 @@ let
             getblock!(q3, BA_3, u, γ, γ)
             @test q3 == q
         end
-
+        fill!(BA_3, 1.0)
+        @test BA_3 == ones(size(BA_3))
+        ran = rand(size(BA_3))
+        copy!(BA_3, ran)
+        @test BA_3 == ran
     end
 end