make mul! fast if first arg is Adjoint, fix block size (#172) (#173)

* make mul! fast if first arg is Adjoint, fix block size (#172)

* v0.15.4

* Update ci.yml

* update docs for Julia v1.6

* Drop Julia v1.5

* Update blockaxis.jl

* increase cov

Author: dlfivefifty

.github/workflows/ci.yml

@@ -10,9 +10,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.5'
-          - '^1.6.0-0'
-          - 'nightly'
+          - '1.6'
         os:
           - ubuntu-latest
           - macOS-latest
@@ -48,7 +46,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@v1
         with:
-          version: '1.5'
+          version: '1'
       - run: |
           julia --project=docs -e '
             using Pkg

Project.toml

@@ -1,16 +1,16 @@
 name = "BlockArrays"
 uuid = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
-version = "0.15.3"
+version = "0.16"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [compat]
-ArrayLayouts = "0.5, 0.6, 0.7"
+ArrayLayouts = "0.7.1"
 FillArrays = "0.11.6"
-julia = "1.5"
+julia = "1.6"
 
 [extras]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

README.md

@@ -11,7 +11,7 @@ Secondly, it also implements two different type of block arrays that follow the
 A simple way to produce `BlockArray`s is via `mortar`, which combines an array of arrays into a `BlockArray`:
 ```julia
 julia> mortar([randn(3), randn(4)])
-2-blocked 7-element BlockArray{Float64,1}:
+2-blocked 7-element BlockVector{Float64}:
  -0.19808699390960527 
   0.04711385377738941 
  -0.6308529482215658  
@@ -22,7 +22,7 @@ julia> mortar([randn(3), randn(4)])
  -0.012442892450142308
 
 julia> mortar(reshape([randn(2,2), randn(1,2), randn(2,3), randn(1,3)],2,2))
-2×2-blocked 3×5 BlockArray{Float64,2}:
+2×2-blocked 3×5 BlockMatrix{Float64}:
  -1.17797    0.359738   │   0.87676    -2.06495    1.74256 
   1.54787    1.64133    │  -0.0416484  -2.00241   -0.522441
  ───────────────────────┼──────────────────────────────────

docs/src/index.md

@@ -14,7 +14,7 @@ Secondly, it also implements two concrete types of block arrays that follow the
 We talk about an “a×b-blocked m×n block array”, if we have ``m \times n`` values arranged in ``a \times b`` blocks, like in the following example:
 
 ```julia
-2×3-blocked 4×4 BlockArray{Float64,2}:
+2×3-blocked 4×4 BlockMatrix{Float64}:
  0.56609   │  0.95429   │  0.0688403  0.980771 
  0.203829  │  0.138667  │  0.0200418  0.0515364
  ──────────┼────────────┼──────────────────────
@@ -25,7 +25,7 @@ We talk about an “a×b-blocked m×n block array”, if we have ``m \times n``
 The dimension of arrays works the same as with standard Julia arrays; for example the following is a ``2 \times 2`` block vector:
 
 ```julia
-2-blocked 4-element BlockArray{Float64,1}:
+2-blocked 4-element BlockVector{Float64}:
  0.35609231970760424
  0.7732179994849591 
  ───────────────────

docs/src/man/abstractblockarrayinterface.md

@@ -20,15 +20,15 @@ An arrays block structure is inferred from an axes, and therefore every array
 is in some sense already a block array:
 ```julia
 julia> A = randn(5,5)
-5×5 Array{Float64,2}:
+5×5 Matrix{Float64}:
   0.452801   -0.416508   1.17406    1.52575     3.1574  
   0.413142   -1.34722   -1.28597    0.637721    0.30655 
   0.34907    -0.887615   0.284972  -0.0212884  -0.225832
   0.466102   -1.10425    1.49226    0.968436   -2.13637 
  -0.0971956  -1.7664    -0.592629  -1.48947     1.53418 
 
 julia> A[Block(1,1)]
-5×5 Array{Float64,2}:
+5×5 Matrix{Float64}:
   0.452801   -0.416508   1.17406    1.52575     3.1574  
   0.413142   -1.34722   -1.28597    0.637721    0.30655 
   0.34907    -0.887615   0.284972  -0.0212884  -0.225832
@@ -50,7 +50,7 @@ that are subtypes of `AbstractBlockArray`:
 * A pretty printing `show` function that uses unicode lines to split up the blocks:
 ```
 julia> A = BlockArray(rand(4, 5), [1,3], [2,3])
-2×2-blocked 4×5 BlockArray{Float64,2}:
+2×2-blocked 4×5 BlockMatrix{Float64}:
 0.61179   0.965631  │  0.696476   0.392796  0.712462
 --------------------┼-------------------------------
 0.620099  0.364706  │  0.0311643  0.27895   0.73477
@@ -62,7 +62,7 @@ julia> A = BlockArray(rand(4, 5), [1,3], [2,3])
 
 ```
 julia> blockcheckbounds(A, 5, 3)
-ERROR: BlockBoundsError: attempt to access 2×2-blocked 4×5 BlockArrays.BlockArray{Float64,2,Array{Float64,2}} at block index [5,3]
+ERROR: BlockBoundsError: attempt to access 2×2-blocked 4×5 BlockMatrix{Float64, Matrix{Float64}} at block index [5,3]
 ```
 
 * Happy users who know how to use your new block array :)

docs/src/man/blockarrays.md

@@ -14,15 +14,15 @@ An `AbstractArray` can be repacked into a `BlockArray` with `BlockArray(array, b
 
 ```julia
 julia> BlockArray(rand(4, 4), [2,2], [1,1,2])
-2×3-blocked 4×4 BlockArray{Float64,2}:
+2×3-blocked 4×4 BlockMatrix{Float64}:
  0.70393   │  0.568703  │  0.0137366  0.953038
  0.24957   │  0.145924  │  0.884324   0.134155
  ──────────┼────────────┼─────────────────────
  0.408133  │  0.707723  │  0.467458   0.326718
  0.844314  │  0.794279  │  0.0421491  0.683791
 
 julia> block_array_sparse = BlockArray(sprand(4, 5, 0.7), [1,3], [2,3])
-2×2-blocked 4×5 BlockArray{Float64,2,Array{SparseMatrixCSC{Float64,Int64},2},Tuple{BlockedUnitRange{Array{Int64,1}},BlockedUnitRange{Array{Int64,1}}}}:
+2×2-blocked 4×5 BlockMatrix{Float64, Matrix{SparseMatrixCSC{Float64, Int64}}, Tuple{BlockedUnitRange{Vector{Int64}}, BlockedUnitRange{Vector{Int64}}}}:
  0.0341601  0.374187  │  0.0118196  0.299058  0.0     
  ---------------------┼-------------------------------
  0.0945445  0.931115  │  0.0460428  0.0       0.0     
@@ -38,7 +38,7 @@ A block array can be created with uninitialized values (but initialized blocks)
 
 ```julia
 julia> BlockArray{Float32}(undef, [1,2,1], [1,1,1])
-3×3-blocked 4×3 BlockArray{Float32,2}:
+3×3-blocked 4×3 BlockMatrix{Float32}:
  -2.15145e-35  │   1.4013e-45   │  -1.77199e-35
  ──────────────┼────────────────┼──────────────
   1.4013e-45   │  -1.77199e-35  │  -1.72473e-34
@@ -56,7 +56,7 @@ A `BlockArray` can be created with the blocks left uninitialized using the `Bloc
 
 ```jldoctest
 julia> BlockArray{Float32}(undef_blocks, [1,2], [3,2])
-2×2-blocked 3×5 BlockArray{Float32,2}:
+2×2-blocked 3×5 BlockMatrix{Float32}:
  #undef  #undef  #undef  │  #undef  #undef
  ────────────────────────┼────────────────
  #undef  #undef  #undef  │  #undef  #undef
@@ -67,7 +67,7 @@ The `block_type` should be an array type.  It specifies the internal block type,
 
 ```julia
 julia> BlockArray(undef_blocks, SparseVector{Float64, Int}, [1,2])
-2-blocked 3-element BlockArray{Float64,1,Array{SparseVector{Float64,Int64},1},Tuple{BlockedUnitRange{Array{Int64,1}}}}:
+2-blocked 3-element BlockVector{Float64, Vector{SparseVector{Float64, Int64}}, Tuple{BlockedUnitRange{Vector{Int64}}}}:
  #undef
  ------
  #undef
@@ -92,21 +92,21 @@ A block can be set by  `block_array[Block(i...)] = v` or
 
 ```jldoctest block_array
 julia> block_array = BlockArray{Float64}(undef_blocks, [1,2], [2,2])
-2×2-blocked 3×4 BlockArray{Float64,2}:
+2×2-blocked 3×4 BlockMatrix{Float64}:
  #undef  #undef  │  #undef  #undef
  ────────────────┼────────────────
  #undef  #undef  │  #undef  #undef
  #undef  #undef  │  #undef  #undef
 
 julia> block_array[Block(2,1)] = rand(2,2)
-2×2 Array{Float64,2}:
+2×2 Matrix{Float64}:
  0.590845  0.566237
  0.766797  0.460085
 
 julia> block_array[Block(1),Block(1)] = [1 2];
 
 julia> block_array
-2×2-blocked 3×4 BlockArray{Float64,2}:
+2×2-blocked 3×4 BlockMatrix{Float64}:
  1.0       2.0       │  #undef  #undef
  ────────────────────┼────────────────
  0.590845  0.566237  │  #undef  #undef
@@ -120,15 +120,15 @@ or if a copy is desired, `block_array[Block(i...)]`:
 
 ```jldoctest block_array
 julia> view(block_array, Block(1, 1))
-1×2 Array{Float64,2}:
+1×2 Matrix{Float64}:
  1.0  2.0
 
 julia> block_array[Block(1, 1)] # makes a copy
-1×2 Array{Float64,2}:
+1×2 Matrix{Float64}:
  1.0  2.0
 
 julia> block_array[Block(1), Block(1)]  # equivalent to above
-1×2 Array{Float64,2}:
+1×2 Matrix{Float64}:
  1.0  2.0
 ```
 
@@ -146,17 +146,17 @@ To view and modify blocks of `BlockArray` use the `view` syntax.
 julia> A = BlockArray(ones(6), 1:3);
 
 julia> view(A, Block(2))
-2-element Array{Float64,1}:
+2-element Vector{Float64}:
  1.0
  1.0
 
 julia> view(A, Block(2)) .= [3,4]; A[Block(2)]
-2-element Array{Float64,1}:
+2-element Vector{Float64}:
  3.0
  4.0
 
 julia> view(A, Block.(1:2))
-3-element view(::BlockArray{Float64,1,Array{Array{Float64,1},1},Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64,UnitRange{Int64}}}}}, BlockSlice(Block{1,Int64}[Block(1), Block(2)],1:1:3)) with eltype Float64 with indices 1:1:3:
+3-element view(::BlockVector{Float64, Vector{Vector{Float64}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, UnitRange{Int64}}}}}, BlockSlice(Block{1, Int64}[Block(1), Block(2)],1:1:3)) with eltype Float64 with indices 1:1:3:
  1.0
  3.0
  4.0
@@ -170,7 +170,7 @@ An array can be repacked into a `BlockArray` with `BlockArray(array, block_sizes
 
 ```jl
 julia> block_array_sparse = BlockArray(sprand(4, 5, 0.7), [1,3], [2,3])
-2×2-blocked 4×5 BlockArray{Float64,2,Array{SparseMatrixCSC{Float64,Int64},2},Tuple{BlockedUnitRange{Array{Int64,1}},BlockedUnitRange{Array{Int64,1}}}}:
+2×2-blocked 4×5 BlockArray{Float64, 2, Matrix{SparseMatrixCSC{Float64, Int64}}, Tuple{BlockedUnitRange{Vector{Int64}}, BlockedUnitRange{Vector{Int64}}}}:
  0.0341601  0.374187  │  0.0118196  0.299058  0.0     
  ---------------------┼-------------------------------
  0.0945445  0.931115  │  0.0460428  0.0       0.0     

docs/src/man/pseudoblockarrays.md

@@ -23,7 +23,7 @@ Creating a `PseudoBlockArray` works in the same way as a `BlockArray`.
 
 ```jldoctest A
 julia> pseudo = PseudoBlockArray(rand(3,3), [1,2], [2,1])
-2×2-blocked 3×3 PseudoBlockArray{Float64,2}:
+2×2-blocked 3×3 PseudoBlockMatrix{Float64}:
  0.590845  0.460085  │  0.200586
  ────────────────────┼──────────
  0.766797  0.794026  │  0.298614
@@ -39,7 +39,7 @@ A block array can be created with uninitialized entries using the `BlockArray{T}
 function. The block_sizes are each an `AbstractVector{Int}` which determines the size of the blocks in that dimension. We here create a `[1,2]×[3,2]` block matrix of `Float32`s:
 ```julia
 julia> PseudoBlockArray{Float32}(undef, [1,2], [3,2])
-2×2-blocked 3×5 PseudoBlockArray{Float32,2}:
+2×2-blocked 3×5 PseudoBlockMatrix{Float32}:
  1.02295e-43  0.0          1.09301e-43  │  0.0          1.17709e-43
  ───────────────────────────────────────┼──────────────────────────
  0.0          1.06499e-43  0.0          │  1.14906e-43  0.0        
@@ -55,14 +55,14 @@ one can use views:
 
 ```jldoctest A
 julia> A = zeros(2,2)
-2×2 Array{Float64,2}:
+2×2 Matrix{Float64}:
  0.0  0.0
  0.0  0.0
 
 julia> copyto!(A, view(pseudo, Block(2, 1)));
 
 julia> A
-2×2 Array{Float64,2}:
+2×2 Matrix{Float64}:
  0.766797  0.794026
  0.566237  0.854147
 ```
@@ -84,12 +84,12 @@ We can also view and modify views of blocks of `PseudoBlockArray` using the `vie
 julia> A = PseudoBlockArray(ones(6), 1:3);
 
 julia> view(A, Block(2))
-2-element view(::Array{Float64,1}, 2:3) with eltype Float64:
+2-element view(::Vector{Float64}, 2:3) with eltype Float64:
  1.0
  1.0
 
 julia> view(A, Block(2)) .= [3,4]; A[Block(2)]
-2-element Array{Float64,1}:
+2-element Vector{Float64}:
  3.0
  4.0
 ```

src/abstractblockarray.jl

@@ -86,7 +86,7 @@ specialize this method if they need to provide custom block bounds checking beha
 julia> A = BlockArray(rand(2,3), [1,1], [2,1]);
 
 julia> blockcheckbounds(A, 3, 2)
-ERROR: BlockBoundsError: attempt to access 2×2-blocked 2×3 BlockArray{Float64,2,Array{Array{Float64,2},2},Tuple{BlockedUnitRange{Array{Int64,1}},BlockedUnitRange{Array{Int64,1}}}} at block index [3,2]
+ERROR: BlockBoundsError: attempt to access 2×2-blocked 2×3 BlockMatrix{Float64, Matrix{Matrix{Float64}}, Tuple{BlockedUnitRange{Vector{Int64}}, BlockedUnitRange{Vector{Int64}}}} at block index [3,2]
 [...]
 ```
 """
@@ -144,23 +144,23 @@ returning views.
 
 ```jldoctest; setup = quote using BlockArrays end
 julia> v = Array(reshape(1:6, (2, 3)))
-2×3 Array{Int64,2}:
+2×3 Matrix{Int64}:
  1  3  5
  2  4  6
 
 julia> A = BlockArray(v, [1,1], [2,1])
-2×2-blocked 2×3 BlockArray{Int64,2}:
+2×2-blocked 2×3 BlockMatrix{Int64}:
  1  3  │  5
  ──────┼───
  2  4  │  6
 
 julia> Matrix.(collect(eachblock(A)))
-2×2 Array{Array{Int64,2},2}:
+2×2 Matrix{Matrix{Int64}}:
  [1 3]  [5]
  [2 4]  [6]
 
 julia> sum.(eachblock(A))
-2×2 Array{Int64,2}:
+2×2 Matrix{Int64}:
  4  5
  6  6
 ```

src/blockarray.jl

@@ -16,7 +16,7 @@ undef_blocks (@ref), an alias for UndefBlocksInitializer().
 # Examples
 ```julia
 julia> BlockArray(undef_blocks, Matrix{Float32}, [1,2], [3,2])
-2×2-blocked 3×5 BlockArray{Float32,2}:
+2×2-blocked 3×5 BlockMatrix{Float32}:
  #undef  #undef  #undef  │  #undef  #undef
  ────────────────────────┼────────────────
  #undef  #undef  #undef  │  #undef  #undef
@@ -35,7 +35,7 @@ array-constructor-caller would like an uninitialized block array.
 # Examples
 ```julia
 julia> BlockArray(undef_blocks, Matrix{Float32}, [1,2], [3,2])
-2×2-blocked 3×5 BlockArray{Float32,2}:
+2×2-blocked 3×5 BlockMatrix{Float32}:
  #undef  #undef  #undef  │  #undef  #undef
  ------------------------┼----------------
  #undef  #undef  #undef  │  #undef  #undef
@@ -101,7 +101,7 @@ Constructs a `BlockArray` with uninitialized blocks from a block type `R` with s
 
 ```jldoctest; setup = quote using BlockArrays end
 julia> BlockArray(undef_blocks, Matrix{Float64}, [1,3], [2,2])
-2×2-blocked 4×4 BlockArray{Float64,2}:
+2×2-blocked 4×4 BlockMatrix{Float64}:
  #undef  #undef  │  #undef  #undef
  ────────────────┼────────────────
  #undef  #undef  │  #undef  #undef
@@ -223,12 +223,12 @@ julia> arrays = permutedims(reshape([
                   1ones(1, 3), 2ones(1, 2),
                   3ones(2, 3), 4ones(2, 2),
               ], (2, 2)))
-2×2 Array{Array{Float64,2},2}:
+2×2 Matrix{Matrix{Float64}}:
  [1.0 1.0 1.0]               [2.0 2.0]
  [3.0 3.0 3.0; 3.0 3.0 3.0]  [4.0 4.0; 4.0 4.0]
 
 julia> mortar(arrays)
-2×2-blocked 3×5 BlockArray{Float64,2}:
+2×2-blocked 3×5 BlockMatrix{Float64}:
  1.0  1.0  1.0  │  2.0  2.0
  ───────────────┼──────────
  3.0  3.0  3.0  │  4.0  4.0