UniformScaling constructors (#112)

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "BlockArrays"
 uuid = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
-version = "0.12.5"
+version = "0.12.6"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"

src/blockarray.jl

@@ -203,6 +203,15 @@ BlockVector(blocks::AbstractVector, block_sizes::AbstractVector{Int}) = BlockArr
 BlockMatrix(blocks::AbstractMatrix, baxes::NTuple{2,AbstractUnitRange{Int}}) = BlockArray(blocks, baxes)
 BlockMatrix(blocks::AbstractMatrix, block_sizes::Vararg{AbstractVector{Int},2}) = BlockArray(blocks, block_sizes...)
 
+BlockArray{T}(λ::UniformScaling, baxes::NTuple{2,AbstractUnitRange{Int}}) where T = BlockArray{T}(Matrix(λ, map(length,baxes)...), baxes)
+BlockArray{T}(λ::UniformScaling, block_sizes::Vararg{AbstractVector{Int}, 2}) where T = BlockArray{T}(λ, map(blockedrange,block_sizes))
+BlockArray(λ::UniformScaling{T}, block_sizes::Vararg{AbstractVector{Int}, 2}) where T = BlockArray{T}(λ, block_sizes...)
+BlockArray(λ::UniformScaling{T}, baxes::NTuple{2,AbstractUnitRange{Int}}) where T = BlockArray{T}(λ, baxes)
+BlockMatrix(λ::UniformScaling, baxes::NTuple{2,AbstractUnitRange{Int}}) = BlockArray(λ, baxes)
+BlockMatrix(λ::UniformScaling, block_sizes::Vararg{AbstractVector{Int},2}) = BlockArray(λ, block_sizes...)
+BlockMatrix{T}(λ::UniformScaling, baxes::NTuple{2,AbstractUnitRange{Int}}) where T = BlockArray{T}(λ, baxes)
+BlockMatrix{T}(λ::UniformScaling, block_sizes::Vararg{AbstractVector{Int},2}) where T = BlockArray{T}(λ, block_sizes...)
+
 """
     mortar(blocks::AbstractArray)
     mortar(blocks::AbstractArray{R, N}, sizes_1, sizes_2, ..., sizes_N)

src/pseudo_blockarray.jl

@@ -100,6 +100,16 @@ PseudoBlockVector(blocks::AbstractVector, block_sizes::AbstractVector{Int}) = Ps
 PseudoBlockMatrix(blocks::AbstractMatrix, baxes::NTuple{2,AbstractUnitRange{Int}}) = PseudoBlockArray(blocks, baxes)
 PseudoBlockMatrix(blocks::AbstractMatrix, block_sizes::Vararg{AbstractVector{Int},2}) = PseudoBlockArray(blocks, block_sizes...)
 
+PseudoBlockArray{T}(λ::UniformScaling, baxes::NTuple{2,AbstractUnitRange{Int}}) where T = PseudoBlockArray{T}(Matrix(λ, map(length,baxes)...), baxes)
+PseudoBlockArray{T}(λ::UniformScaling, block_sizes::Vararg{AbstractVector{Int}, 2}) where T = PseudoBlockArray{T}(λ, map(blockedrange,block_sizes))
+PseudoBlockArray(λ::UniformScaling{T}, block_sizes::Vararg{AbstractVector{Int}, 2}) where T = PseudoBlockArray{T}(λ, block_sizes...)
+PseudoBlockArray(λ::UniformScaling{T}, baxes::NTuple{2,AbstractUnitRange{Int}}) where T = PseudoBlockArray{T}(λ, baxes)
+PseudoBlockMatrix(λ::UniformScaling, baxes::NTuple{2,AbstractUnitRange{Int}}) = PseudoBlockArray(λ, baxes)
+PseudoBlockMatrix(λ::UniformScaling, block_sizes::Vararg{AbstractVector{Int},2}) = PseudoBlockArray(λ, block_sizes...)
+PseudoBlockMatrix{T}(λ::UniformScaling, baxes::NTuple{2,AbstractUnitRange{Int}}) where T = PseudoBlockArray{T}(λ, baxes)
+PseudoBlockMatrix{T}(λ::UniformScaling, block_sizes::Vararg{AbstractVector{Int},2}) where T = PseudoBlockArray{T}(λ, block_sizes...)
+
+
 # Convert AbstractArrays that conform to block array interface
 convert(::Type{PseudoBlockArray{T,N,R,BS}}, A::PseudoBlockArray{T,N,R,BS}) where {T,N,R,BS} = A
 convert(::Type{PseudoBlockArray{T,N,R}}, A::PseudoBlockArray{T,N,R}) where {T,N,R} = A

test/test_blockarrays.jl

@@ -74,6 +74,7 @@ end
             BlockArray(A, (blockedrange(1:3),)) == BlockArray{Int}(A, (blockedrange(1:3),)) ==
             BlockArray{Float64}(A, 1:3)
     end
+
     @testset "PseudoBlockArray constructors" begin
         ret = PseudoBlockArray{Float64}(undef, 1:3)
         fill!(ret, 0)
@@ -171,6 +172,7 @@ end
         @test a == [3,2,3]
         @test a_data == [3,2,3]
     end
+
     @testset "BlockMatrix" begin
         a_data = [1 2; 3 4]
         a = BlockMatrix(a_data,[1,1],[2])
@@ -190,6 +192,36 @@ end
         @test a == [3 2; 3 4]
         @test a_data == [3 2; 3 4]
     end
+
+    @testset "UniformScaling" begin
+        B = BlockArray(I, fill(2,4), fill(2,5))
+        @test B isa BlockMatrix{Bool}
+        @test B == BlockMatrix(I, fill(2,4), fill(2,5)) ==
+                    BlockArray(I, blockedrange.((fill(2,4), fill(2,5)))) == 
+                    BlockMatrix(I, blockedrange.((fill(2,4), fill(2,5)))) == 
+                    Matrix(I, 8, 10)
+        
+        B = BlockArray{Float64}(I, fill(2,4), fill(2,5))
+        @test B isa BlockMatrix{Float64}
+        @test B == BlockMatrix{Float64}(I, fill(2,4), fill(2,5)) ==
+                    BlockArray{Float64}(I, blockedrange.((fill(2,4), fill(2,5)))) == 
+                    BlockMatrix{Float64}(I, blockedrange.((fill(2,4), fill(2,5)))) == 
+                    Matrix(I, 8, 10)
+
+        B = PseudoBlockArray(I, fill(2,4), fill(2,5))
+        @test B isa PseudoBlockMatrix{Bool}
+        @test B == PseudoBlockMatrix(I, fill(2,4), fill(2,5)) ==
+                    PseudoBlockArray(I, blockedrange.((fill(2,4), fill(2,5)))) == 
+                    PseudoBlockMatrix(I, blockedrange.((fill(2,4), fill(2,5)))) == 
+                    Matrix(I, 8, 10)
+        
+        B = PseudoBlockArray{Float64}(I, fill(2,4), fill(2,5))
+        @test B isa PseudoBlockMatrix{Float64}
+        @test B == PseudoBlockMatrix{Float64}(I, fill(2,4), fill(2,5)) ==
+                    PseudoBlockArray{Float64}(I, blockedrange.((fill(2,4), fill(2,5)))) == 
+                    PseudoBlockMatrix{Float64}(I, blockedrange.((fill(2,4), fill(2,5)))) == 
+                    Matrix(I, 8, 10)
+    end
 end
 
 @testset "block indexing" begin