Fix various typos (#1149)

Signed-off-by: Alexander Seiler <seileralex@gmail.com>

Author: goggle

docs/src/pages/api.md

@@ -162,7 +162,7 @@ aliases, e.g. `sa = SizedMatrix{2,2}(a)`.
 
 Then, methods on `sa` will use the specialized code provided by the *StaticArrays*
 package, which in many cases will be much, much faster. For example, calling
-`eigen(sa)` will be signficantly faster than `eigen(a)` since it will perform a
+`eigen(sa)` will be significantly faster than `eigen(a)` since it will perform a
 specialized 2×2 matrix diagonalization rather than a general algorithm provided
 by Julia and *LAPACK*.
 

perf/bench1.txt

@@ -6,7 +6,7 @@ Observations: - FixedSizeArrays matrix multiplications is slightly slower than S
               - Compilation time is significant for large matrix multiplication
               - SIMD leads to a factor of two improvement (128 bit registers for 64 bit floats) for both SArray and Mat
               - MArray is quite slow at matrix multiplication, for 10x10 upwards
-              - Large MArray's are slower than Array for some elementwise operations (Can we get it to process chuncks or something?)
+              - Large MArray's are slower than Array for some elementwise operations (Can we get it to process chunks or something?)
               - Inlining may need to be turned off for large array operations
               - Can we use BLAS for more operations, where that makes sense?
 

perf/bench2.txt

@@ -3,7 +3,7 @@
 
 Notes: Got a loop version working. There were some fixes with boundschecks and
        with loading a value from an MMatrix. (It turns out that mutable
-       containers will copy their entire tuple accross and index that, so we
+       containers will copy their entire tuple across and index that, so we
        now revert to a pointer-based approach for loads as well as stores).
 
        The second set or results has re-enabled the bounds checking on MMatrix.

perf/bench8.txt

@@ -52,11 +52,11 @@ end
     return SizedArray{S,T,N,N,Array{T,N}}(x)
 end
 
-# Overide some problematic default behaviour
+# Override some problematic default behaviour
 @inline convert(::Type{SA}, sa::SizedArray) where {SA<:SizedArray} = SA(sa.data)
 @inline convert(::Type{SA}, sa::SA) where {SA<:SizedArray} = sa
 
-# Back to Array (unfortunately need both convert and construct to overide other methods)
+# Back to Array (unfortunately need both convert and construct to override other methods)
 @inline function Base.Array(sa::SizedArray{S}) where {S}
     return Array(reshape(sa.data, size_to_tuple(S)))
 end

src/SizedArray.jl

@@ -52,7 +52,7 @@ The default returned `SA′` is `SA` itself for user defined `StaticArray`s. Thi
     Otherwise construction might fall into infinite recursion.
 
 ---
-The adaption rules for offical `StaticArray`s could be summarized as:
+The adaption rules for official `StaticArray`s could be summarized as:
 
 # `SA <: FieldArray`: `eltype` adaptable
 
@@ -215,4 +215,4 @@ end
 
 # `float` and `real` of StaticArray types, analogously to application to scalars (issue 935)
 float(::Type{SA}) where SA<:StaticArray{_S,T,_N} where {_S,T,_N} = similar_type(SA, float(T))
-real(::Type{SA}) where SA<:StaticArray{_S,T,_N} where {_S,T,_N} = similar_type(SA, real(T))
+real(::Type{SA}) where SA<:StaticArray{_S,T,_N} where {_S,T,_N} = similar_type(SA, real(T))

src/convert.jl

@@ -95,7 +95,7 @@ issuccess(F::LU) = _first_zero_on_diagonal(F.U) == 0
             # call through to Base to avoid excessive time spent on type inference for large matrices
             f = lu(Matrix(A), $(_pivot); check = check)
             # Trick to get the output eltype - can't rely on the result of f.L as
-            # it's not type inferrable.
+            # it's not type inferable.
             T2 = arithmetic_closure(T)
             L = similar_type(A, T2, Size($M, $(min(M,N))))(f.L)
             U = similar_type(A, T2, Size($(min(M,N)), $N))(f.U)
@@ -197,7 +197,7 @@ end
 # Create SVector(2,3,...,M)
 # Note that
 #     tailindices(::Type{Val{M}}) where {M} = SVector(Base.tail(ntuple(identity, Val{M})))
-# works, too, but is only inferrable for M ≤ 14 (at least up to Julia 0.7.0-DEV.4021)
+# works, too, but is only inferable for M ≤ 14 (at least up to Julia 0.7.0-DEV.4021)
 @generated function tailindices(::Type{Val{M}}) where {M}
     :(SVector{$(M-1),Int}($(tuple(2:M...))))
 end

src/lu.jl

@@ -87,7 +87,7 @@ end
 """
     gen_by_access(expr_gen, a::Type{<:AbstractArray}, b::Type{<:AbstractArray})
 
-Simiar to gen_by_access with only one type argument. The difference is that tests for both
+Similar to gen_by_access with only one type argument. The difference is that tests for both
 arrays of type `a` and `b` are generated and `expr_gen` receives two access arguments,
 first for matrix `a` and the second for matrix `b`.
 """
@@ -213,7 +213,7 @@ const StaticVecOrMatLikeForFiveArgMulDest{T} = Union{
 }
 
 # 5-argument matrix multiplication
-#    To avoid allocations, strip away Transpose type and store tranpose info in Size
+#    To avoid allocations, strip away Transpose type and store transpose info in Size
 @inline LinearAlgebra.mul!(dest::StaticVecOrMatLikeForFiveArgMulDest, A::StaticVecOrMatLike, B::StaticVecOrMatLike,
     α::Number, β::Number) = _mul!(TSize(dest), mul_parent(dest), Size(A), Size(B), A, B,
     AlphaBeta(α,β))

src/matrix_multiply_add.jl

@@ -25,7 +25,7 @@ Base.iterate(S::SVD, ::Val{:done}) = nothing
 
 function svdvals(A::StaticMatrix)
     sv = svdvals(Matrix(A))
-    # We should be using `T2=eltype(sv)`, but it's not inferrable for complex
+    # We should be using `T2=eltype(sv)`, but it's not inferable for complex
     # eltypes.  See https://github.com/JuliaLang/julia/pull/22443
     T = eltype(A)
     T2 = promote_type(Float32, real(typeof(one(T)/norm(one(T)))))

src/svd.jl

@@ -37,7 +37,7 @@ using StaticArrays, Test, LinearAlgebra
         @test sqrt(m) == sqrt(m2)
         @test cholesky(m).U == cholesky(m2).U
 
-        # Aparently recursive chol never really worked
+        # Apparently recursive chol never really worked
         #@test_broken chol(reshape([1.0*m, 0.0*m, 0.0*m, 1.0*m], 2, 2)) ==
         #    reshape([chol(1.0*m), 0.0*m, 0.0*m, chol(1.0*m)], 2, 2)