Fix some typos (#254)

Signed-off-by: Alexander Seiler <[email protected]>

Author: goggle

src/abstractblockarray.jl

@@ -174,7 +174,7 @@ function eachblock(A::AbstractBlockArray)
     (view(A, Block(Tuple(I))) for I in blockinds)
 end
 
-# Use memory laout for sub-blocks
+# Use memory layout for sub-blocks
 @inline Base.getindex(A::AbstractMatrix, kr::Colon, jr::Block{1}) = ArrayLayouts.layout_getindex(A, kr, jr)
 @inline Base.getindex(A::AbstractMatrix, kr::Block{1}, jr::Colon) = ArrayLayouts.layout_getindex(A, kr, jr)
 @inline Base.getindex(A::AbstractMatrix, kr::Block{1}, jr::AbstractVector) = ArrayLayouts.layout_getindex(A, kr, jr)

src/blockarray.jl

@@ -66,7 +66,7 @@ struct BlockArray{T, N, R <: AbstractArray{<:AbstractArray{T,N},N}, BS<:NTuple{N
         new{T, N, R, BS}(blocks, block_sizes)
 end
 
-# Auxilary outer constructors
+# Auxiliary outer constructors
 @inline _BlockArray(blocks::R, block_sizes::Vararg{AbstractVector{<:Integer}, N}) where {T, N, R<:AbstractArray{<:AbstractArray{T,N},N}} =
     _BlockArray(blocks, map(blockedrange, block_sizes))
 
@@ -97,7 +97,7 @@ end
     _BlockArray(R, block_sizes...)
 
 """
-Constructs a `BlockArray` with uninitialized blocks from a block type `R` with sizes defind by `block_sizes`.
+Constructs a `BlockArray` with uninitialized blocks from a block type `R` with sizes defined by `block_sizes`.
 
 ```jldoctest; setup = quote using BlockArrays end
 julia> BlockArray(undef_blocks, Matrix{Float64}, [1,3], [2,2])

src/blockindices.jl

@@ -312,7 +312,7 @@ end
 
 represents a cartesian range of blocks.
 
-The relationship between `Block` and `BlockRange` mimicks the relationship between
+The relationship between `Block` and `BlockRange` mimics the relationship between
 `CartesianIndex` and `CartesianRange`.
 """
 BlockRange

src/blockreduce.jl

@@ -17,5 +17,5 @@ Base.mapfoldl(f::F, op::OP, B::PseudoBlockArray; kw...) where {F, OP} =
 Base.mapreduce(f::F, op::OP, B::PseudoBlockArray; kw...) where {F, OP} =
     mapreduce(f, op, B.blocks; kw...)
 
-# support sum, need to return something analoguous to Base.OneTo(1) but same type
+# support sum, need to return something analogous to Base.OneTo(1) but same type
 Base.reduced_index(::BR) where BR<:BlockedUnitRange = convert(BR, Base.OneTo(1))

src/pseudo_blockarray.jl

@@ -1,4 +1,4 @@
-# Note: Functions surrounded by a comment blocks are there because `Vararg` is sitll allocating.
+# Note: Functions surrounded by a comment blocks are there because `Vararg` is still allocating.
 # When Vararg is fast enough, they can simply be removed
 
 ####################

test/test_blockbroadcast.jl

@@ -178,7 +178,7 @@ import BlockArrays: SubBlockIterator, BlockIndexRange, Diagonal
         @test blockisequal(axes(A .* Ones(axes(A))), axes(Ones(axes(A)) .* A), axes(A .* ones(6)))
     end
 
-    @testset "type inferrence" begin
+    @testset "type inference" begin
         u = BlockArray(randn(5), [2,3]);
         @inferred(copyto!(similar(u), Base.broadcasted(exp, u)))
         @test exp.(u) == exp.(Vector(u))