add conversion between block arrays (#27)

Author: KristofferC

src/BlockArrays.jl

@@ -18,6 +18,7 @@ include("blocksizes.jl")
 include("blockindices.jl")
 include("blockarray.jl")
 include("pseudo_blockarray.jl")
+include("convert.jl")
 include("show.jl")
 
 

src/blockarray.jl

@@ -27,7 +27,6 @@ function BlockArray(blocks::Array{R, N}, block_sizes::Vararg{Vector{Int}, N}) wh
     return BlockArray{T, N, R}(blocks, BlockSizes(block_sizes...))
 end
 
-
 const BlockMatrix{T, R <: AbstractMatrix{T}} = BlockArray{T, 2, R}
 const BlockVector{T, R <: AbstractVector{T}} = BlockArray{T, 1, R}
 const BlockVecOrMat{T, R} = Union{BlockMatrix{T, R}, BlockVector{T, R}}
@@ -60,19 +59,21 @@ function BlockArray{T, N, R <: AbstractArray{T,N}}(::Type{R}, block_sizes::Block
     BlockArray{T,N,R}(blocks, block_sizes)
 end
 
-@generated function BlockArray{T, N}(arr::AbstractArray{T, N}, block_sizes::Vararg{Vector{Int}, N})
-    return quote
-        for i in 1:N
-            if sum(block_sizes[i]) != size(arr, i)
-                throw(DimensionMismatch("block size for dimension $i: $(block_sizes[i]) does not sum to the array size: $(size(arr, i))"))
-            end
+function BlockArray{T, N}(arr::AbstractArray{T, N}, block_sizes::Vararg{Vector{Int}, N})
+    for i in 1:N
+        if sum(block_sizes[i]) != size(arr, i)
+            throw(DimensionMismatch("block size for dimension $i: $(block_sizes[i]) does not sum to the array size: $(size(arr, i))"))
         end
+    end
+    BlockArray(arr, BlockSizes(block_sizes...))
+end
 
-        _block_sizes = BlockSizes(block_sizes...)
-        block_arr = BlockArray(typeof(arr), _block_sizes)
-        @nloops $N i i->(1:nblocks(_block_sizes, i)) begin
+@generated function BlockArray{T, N}(arr::AbstractArray{T, N}, block_sizes::BlockSizes{N})
+    return quote
+        block_arr = BlockArray(typeof(arr), block_sizes)
+        @nloops $N i i->(1:nblocks(block_sizes, i)) begin
             block_index = @ntuple $N i
-            indices = globalrange(_block_sizes, block_index)
+            indices = globalrange(block_sizes, block_index)
             setblock!(block_arr, arr[indices...], block_index...)
         end
 

src/convert.jl

@@ -0,0 +1,15 @@
+function Base.convert{T, T2, N}(::Type{BlockArray{T, N}}, A::PseudoBlockArray{T2, N})
+    BlockArray(convert(Array{T, N}, Array(A)), A.block_sizes)
+end
+Base.convert{T, T2, N, R}(::Type{BlockArray{T, N, R}}, A::PseudoBlockArray{T2, N}) = convert(BlockArray{T, N}, A)
+Base.convert{T1, T2, N}(::Type{BlockArray{T1}}, A::PseudoBlockArray{T2, N}) = convert(BlockArray{T1, N}, A)
+Base.convert{T, N}(::Type{BlockArray}, A::PseudoBlockArray{T, N}) = convert(BlockArray{T, N}, A)
+BlockArray(A::BlockArray) = convert(BlockArray, A)
+
+function Base.convert{T, T2, N}(::Type{PseudoBlockArray{T, N}}, A::BlockArray{T2, N})
+    PseudoBlockArray(convert(Array{T, N}, Array(A)), A.block_sizes)
+end
+Base.convert{T, T2, N, R}(::Type{PseudoBlockArray{T, N, R}}, A::BlockArray{T2, N}) = convert(PseudoBlockArray{T, N}, A)
+Base.convert{T, N}(::Type{PseudoBlockArray}, A::BlockArray{T, N}) = convert(PseudoBlockArray{T, N}, A)
+Base.convert{T1, T2, N}(::Type{PseudoBlockArray{T1}}, A::BlockArray{T2, N}) = convert(PseudoBlockArray{T1, N}, A)
+PseudoBlockArray(A::BlockArray) = convert(PseudoBlockArray, A)

test/test_blockarrays.jl

@@ -111,6 +111,36 @@ end
     end
 end
 
+@testset "convert" begin
+    # Could probably be DRY'd.
+    A = PseudoBlockArray(rand(2,3), [1,1], [2,1])
+    C = convert(BlockArray, A)
+    @test C == A == BlockArray(A)
+    @test eltype(C) == eltype(A)
+
+    C = convert(BlockArray{Float32}, A)
+    @test C ≈ A ≈ BlockArray(A)
+    @test eltype(C) == Float32
+
+    C = convert(BlockArray{Float32, 2}, A)
+    @test C ≈ A ≈ BlockArray(A)
+    @test eltype(C) == Float32
+
+
+    A = BlockArray(rand(2,3), [1,1], [2,1])
+    C = convert(PseudoBlockArray, A)
+    @test C == A == PseudoBlockArray(A)
+    @test eltype(C) == eltype(A)
+
+    C = convert(PseudoBlockArray{Float32}, A)
+    @test C ≈ A ≈ PseudoBlockArray(A)
+    @test eltype(C) == Float32
+
+    C = convert(PseudoBlockArray{Float32, 2}, A)
+    @test C ≈ A ≈ PseudoBlockArray(A)
+    @test eltype(C) == Float32
+end
+
 @testset "string" begin
     A = BlockArray(rand(4, 5), [1,3], [2,3]);
     buf = IOBuffer()