Checking Benchmark CI in my local repo for [Drop support for versions of Julia lower than v1.6]

.github/workflows/TagBot.yml

@@ -12,3 +12,4 @@ jobs:
       - uses: JuliaRegistries/TagBot@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
+          ssh: ${{ secrets.DOCUMENTER_KEY }}

.github/workflows/benchmark.yml

@@ -10,7 +10,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@latest
         with:
-          version: 1.4
+          version: 1.6
       - name: Install dependencies
         run: julia -e 'using Pkg; pkg"add PkgBenchmark [email protected]"'
       - name: Run benchmarks

.github/workflows/ci.yml

@@ -13,11 +13,8 @@ jobs:
     strategy:
       matrix:
         version:
-          - '1.0'
-          - '1.1'
-          - '1.2'
-          - '1.3'
-          - '1.4'
+          - '1.6'
+          - '1'
           - 'nightly'
         os:
           - ubuntu-latest
@@ -31,13 +28,6 @@ jobs:
           # See https://github.com/marketplace/actions/setup-julia-environment
           # MacOS not available on x86
           - {os: 'macOS-latest', arch: 'x86'}
-          # Don't test on all versions
-          - {os: 'macOS-latest', version: '1.1'}
-          - {os: 'macOS-latest', version: '1.2'}
-          - {os: 'macOS-latest', version: '1.3'}
-          - {os: 'windows-latest', version: '1.1'}
-          - {os: 'windows-latest', version: '1.2'}
-          - {os: 'windows-latest', version: '1.3'}
     steps:
       - uses: actions/checkout@v1
       - uses: julia-actions/setup-julia@latest
@@ -56,7 +46,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: julia-actions/setup-julia@latest
         with:
-          version: '1.4'
+          version: '1.6'
       - run: julia --project=docs -e '
           using Pkg;
           Pkg.develop(PackageSpec(; path=pwd()));

Project.toml

@@ -1,14 +1,14 @@
 name = "StaticArrays"
 uuid = "90137ffa-7385-5640-81b9-e52037218182"
-version = "1.0.2"
+version = "1.4.0"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
 [compat]
-julia = "1"
+julia = "1.6"
 
 [extras]
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"

docs/Project.toml

@@ -2,4 +2,4 @@
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 
 [compat]
-Documenter = "~0.22"
+Documenter = "~0.26"

docs/make.jl

@@ -1,15 +1,21 @@
-using Documenter, StaticArrays
+using Documenter
+using StaticArrays
 
-makedocs(
-         modules = [StaticArrays],
-         sitename = "StaticArrays.jl",
-         pages = [
-            "Home" => "index.md",
-            "API" => "pages/api.md",
-            "Quick Start" => "pages/quickstart.md",
-            ],
-        )
+# Setup for doctests in docstrings
+DocMeta.setdocmeta!(StaticArrays, :DocTestSetup, :(using LinearAlgebra, StaticArrays))
 
-deploydocs(
-    repo = "github.com/JuliaArrays/StaticArrays.jl.git",
+makedocs(;
+    modules = [StaticArrays],
+    format = Documenter.HTML(
+        canonical = "https://JuliaArrays.github.io/StaticArrays.jl/stable/",
+        assets = ["assets/favicon.ico"],
+    ),
+    pages = [
+        "Home" => "index.md",
+        "API" => "pages/api.md",
+        "Quick Start" => "pages/quickstart.md",
+        ],
+    sitename = "StaticArrays.jl",
 )
+
+deploydocs(; repo = "github.com/JuliaArrays/StaticArrays.jl")

docs/src/index.md

@@ -2,7 +2,7 @@
 *Statically sized arrays for Julia*
 
 **StaticArrays** provides a framework for implementing statically sized arrays
-in Julia (≥ 0.5), using the abstract type `StaticArray{Size,T,N} <: AbstractArray{T,N}`.
+in Julia, using the abstract type `StaticArray{Size,T,N} <: AbstractArray{T,N}`.
 Subtypes of [`StaticArray`](@ref) will provide fast implementations of common array and
 linear algebra operations. Note that here "statically sized" means that the
 size can be determined from the *type*, and "static" does **not** necessarily
@@ -15,24 +15,3 @@ as [`SizedArray`](@ref) for annotating standard `Array`s with static size inform
 Further, the abstract [`FieldVector`](@ref) can be used to make fast static vectors
 out of any uniform Julia "struct".
 
-## Migrating code from Julia v0.6 to Julia v0.7
-
-When upgrading code that is depending on **StaticArrays** the following notes may be helpful
-
-* `chol` has been renamed to `cholesky` and return a factorization object. To obtain the factor
-  use `C = cholesky(A).U`, just like for regular Julia arrays.
-
-* `lu` now return a factorization object instead of a tuple with `L`, `U`, and `p`.
-  They can be obtained by destructing via iteration (`L, U, p = lu(A)`) or by
-  using `getfield` (`F = lu(A); L, U, p = F.L, F.U, F.p`).
-
-* `qr` now return a factorization object instead of a tuple with `Q` and `R`.
-  They can be obtained by destructing via iteration (`Q, R = qr(A)`) or by
-  using `getfield` (`F = qr(A); Q, R = F.Q, F.R`)
-
-* `eig` has been renamed to `eigen`, which return a factorization object, rather than
-  a tuple with `(values, vectors)`. They can be obtained by destructing via iteration
-  (`values, vectors = eigen(A)`) or by using `getfield`
-  (`E = eigen(A); values, vectors = E.values, E.vectors`).
-
-* `unshift` and `shift` have been renamed to `pushfirst` and `popfirst`.

docs/src/pages/api.md

@@ -120,6 +120,10 @@ Use of `similar` will fall back to a mutable container, such as a `MVector`
 static size (or else a dynamically sized `Array` will be generated when
 specifying the size as plain integers).
 
+### Collecting directly into static arrays
+
+You can collect [iterators](https://docs.julialang.org/en/v1/manual/interfaces/#man-interface-iteration) into static arrays directly with [`StaticArrays.sacollect`](@ref). The size needs to be specified, but the element type is optional.
+
 ### Mutable arrays: `MVector`, `MMatrix` and `MArray`
 
 These statically sized arrays are identical to the above, but are defined as
@@ -185,6 +189,10 @@ even permute the coordinates with `p[SVector(3,2,1)]`). Furthermore, `Point3D`
 is a complete `AbstractVector` implementation where you can add, subtract or
 scale vectors, multiply them by matrices, etc.
 
+*Note*: the three components of an ordinary `v::SVector{3}` can also be
+accessed as `v.x`, `v.y`, and `v.z`, so there is no need for a `FieldVector`
+to use this convention.
+
 It is also worth noting that `FieldVector`s may be mutable or immutable, and
 that `setindex!` is defined for use on mutable types. For immutable containers,
 you may want to define a method for `similar_type` so that operations leave the

docs/src/pages/quickstart.md

@@ -49,6 +49,23 @@ v1[SVector(3,2,1)] === @SVector [3, 2, 1]
 v1[:] === v1
 typeof(v1[[1,2,3]]) <: Vector # Can't determine size from the type of [1,2,3]
 
+# For geometric and computer graphics applications in dimensions 1 to 4, the
+# conventional dimension names x,y,z,w can be used to access elements of the
+# vector:
+
+u = SA[1,2,3,4]
+
+u.x === u[1]
+u.y === u[2]
+u.z === u[3]
+u.w === u[4]
+
+# The x,y,z and w properties also work to set values in those dimensions:
+m6 = MVector(1,2)
+m6.x = 10
+# The following is now true
+m6[1] === 10
+
 # Is (partially) hooked into BLAS, LAPACK, etc:
 rand(MMatrix{20,20}) * rand(MMatrix{20,20}) # large matrices can use BLAS
 eigen(m3) # eigen(), etc uses specialized algorithms up to 3×3, or else LAPACK

src/MArray.jl

@@ -84,7 +84,7 @@ end
     if isbitstype(T)
         return GC.@preserve v unsafe_load(Base.unsafe_convert(Ptr{T}, pointer_from_objref(v)), i)
     end
-    v.data[i]
+    getfield(v,:data)[i]
 end
 
 @propagate_inbounds function setindex!(v::MArray, val, i::Int)
@@ -102,7 +102,7 @@ end
     return v
 end
 
-@inline Tuple(v::MArray) = v.data
+@inline Tuple(v::MArray) = getfield(v,:data)
 
 Base.dataids(ma::MArray) = (UInt(pointer(ma)),)
 

src/MVector.jl

@@ -99,3 +99,24 @@ macro MVector(ex)
         error("Use @MVector [a,b,c] or @MVector([a,b,c])")
     end
 end
+
+# Named field access for the first four elements, using the conventional field
+# names from low-dimensional geometry (x,y,z) and computer graphics (w).
+let dimension_names = QuoteNode.([:x, :y, :z, :w])
+    body = :(getfield(v, name))
+    for (i,dim_name) in enumerate(dimension_names)
+        body = :(name === $(dimension_names[i]) ? getfield(v, :data)[$i] : $body)
+        @eval @inline function Base.getproperty(v::Union{SVector{$i},MVector{$i}},
+                                                name::Symbol)
+            $body
+        end
+    end
+
+    body = :(setfield!(v, name, e))
+    for (i,dim_name) in enumerate(dimension_names)
+        body = :(name === $dim_name ? @inbounds(v[$i] = e) : $body)
+        @eval @inline function Base.setproperty!(v::MVector{$i}, name::Symbol, e)
+            $body
+        end
+    end
+end

src/SArray.jl

@@ -113,10 +113,10 @@ sacollect
 ####################
 
 @propagate_inbounds function getindex(v::SArray, i::Int)
-    v.data[i]
+    getfield(v,:data)[i]
 end
 
-@inline Tuple(v::SArray) = v.data
+@inline Tuple(v::SArray) = getfield(v,:data)
 
 Base.dataids(::SArray) = ()
 

src/SDiagonal.jl

@@ -39,6 +39,7 @@ one(::Type{SDiagonal{N,T}}) where {N,T} = SDiagonal(ones(SVector{N,T}))
 one(::SDiagonal{N,T}) where {N,T} = SDiagonal(ones(SVector{N,T}))
 
 Base.zero(::SDiagonal{N,T}) where {N,T} = SDiagonal(zeros(SVector{N,T}))
+Base.zero(::Type{SDiagonal{N,T}}) where {N,T} = SDiagonal(zeros(SVector{N,T}))
 
 function LinearAlgebra.cholesky(D::SDiagonal)
     any(x -> x < 0, D.diag) && throw(LinearAlgebra.PosDefException(1))

src/SMatrix.jl

@@ -89,37 +89,45 @@ macro SMatrix(ex)
         s2 = length(ex.args) - 1
         return esc(Expr(:call, Expr(:curly, :SMatrix, s1, s2, ex.args[1]), Expr(:tuple, ex.args[2:end]...)))
     elseif ex.head == :vcat
-        if isa(ex.args[1], Expr) && ex.args[1].head == :row # n x m
+        if isa(ex.args[1], Expr) && (ex.args[1]::Expr).head == :row # n x m
             # Validate
             s1 = length(ex.args)
-            s2s = map(i -> ((isa(ex.args[i], Expr) && ex.args[i].head == :row) ? length(ex.args[i].args) : 1), 1:s1)
+            s2s = let s1=s1, ex=ex
+                map(i -> ((isa(ex.args[i], Expr) && (ex.args[i]::Expr).head == :row) ? length((ex.args[i]::Expr).args) : 1), 1:s1)
+            end
             s2 = minimum(s2s)
             if maximum(s2s) != s2
                 throw(ArgumentError("Rows must be of matching lengths"))
             end
 
-            exprs = [ex.args[i].args[j] for i = 1:s1, j = 1:s2]
+            exprs = let s1=s1, s2=s2, ex=ex
+                [ex.args[i].args[j] for i = 1:s1, j = 1:s2]
+            end
             return esc(Expr(:call, SMatrix{s1, s2}, Expr(:tuple, exprs...)))
         else # n x 1
             return esc(Expr(:call, SMatrix{length(ex.args), 1}, Expr(:tuple, ex.args...)))
         end
     elseif ex.head == :typed_vcat
-        if isa(ex.args[2], Expr) && ex.args[2].head == :row # typed, n x m
+        if isa(ex.args[2], Expr) && (ex.args[2]::Expr).head == :row # typed, n x m
             # Validate
             s1 = length(ex.args) - 1
-            s2s = map(i -> ((isa(ex.args[i+1], Expr) && ex.args[i+1].head == :row) ? length(ex.args[i+1].args) : 1), 1:s1)
+            s2s = let s1=s1, ex=ex
+                map(i -> ((isa(ex.args[i+1], Expr) && (ex.args[i+1]::Expr).head == :row) ? length((ex.args[i+1]::Expr).args) : 1), 1:s1)
+            end
             s2 = minimum(s2s)
             if maximum(s2s) != s2
                 throw(ArgumentError("Rows must be of matching lengths"))
             end
 
-            exprs = [ex.args[i+1].args[j] for i = 1:s1, j = 1:s2]
+            exprs = let s1=s1, s2=s2, ex=ex
+                [ex.args[i+1].args[j] for i = 1:s1, j = 1:s2]
+            end
             return esc(Expr(:call, Expr(:curly, :SMatrix,s1, s2, ex.args[1]), Expr(:tuple, exprs...)))
         else # typed, n x 1
             return esc(Expr(:call, Expr(:curly, :SMatrix, length(ex.args)-1, 1, ex.args[1]), Expr(:tuple, ex.args[2:end]...)))
         end
     elseif isa(ex, Expr) && ex.head == :comprehension
-        if length(ex.args) != 1 || !isa(ex.args[1], Expr) || ex.args[1].head != :generator
+        if length(ex.args) != 1 || !isa(ex.args[1], Expr) || (ex.args[1]::Expr).head != :generator
             error("Expected generator in comprehension, e.g. [f(i,j) for i = 1:3, j = 1:3]")
         end
         ex = ex.args[1]
@@ -138,7 +146,7 @@ macro SMatrix(ex)
             $(esc(Expr(:call, Expr(:curly, :SMatrix, length(rng1), length(rng2)), Expr(:tuple, exprs...))))
         end
     elseif isa(ex, Expr) && ex.head == :typed_comprehension
-        if length(ex.args) != 2 || !isa(ex.args[2], Expr) || ex.args[2].head != :generator
+        if length(ex.args) != 2 || !isa(ex.args[2], Expr) || (ex.args[2]::Expr).head != :generator
             error("Expected generator in typed comprehension, e.g. Float64[f(i,j) for i = 1:3, j = 1:3]")
         end
         T = ex.args[1]
@@ -158,7 +166,7 @@ macro SMatrix(ex)
             $(esc(Expr(:call, Expr(:curly, :SMatrix, length(rng1), length(rng2), T), Expr(:tuple, exprs...))))
         end
     elseif isa(ex, Expr) && ex.head == :call
-        if ex.args[1] == :zeros || ex.args[1] == :ones || ex.args[1] == :rand || ex.args[1] == :randn || ex.args[1] == :randexp
+        if ex.args[1] === :zeros || ex.args[1] === :ones || ex.args[1] === :rand || ex.args[1] === :randn || ex.args[1] === :randexp
             if length(ex.args) == 3
                 return quote
                     $(ex.args[1])(SMatrix{$(esc(ex.args[2])),$(esc(ex.args[3]))})
@@ -170,7 +178,7 @@ macro SMatrix(ex)
             else
                 error("@SMatrix expected a 2-dimensional array expression")
             end
-        elseif ex.args[1] == :fill
+        elseif ex.args[1] === :fill
             if length(ex.args) == 4
                 return quote
                     $(esc(ex.args[1]))($(esc(ex.args[2])), SMatrix{$(esc(ex.args[3])), $(esc(ex.args[4]))})

src/SUnitRange.jl

@@ -25,7 +25,9 @@ end
     return Start + i - 1
 end
 
-# Shorten show for REPL use.
-function show(io::IO, ::MIME"text/plain", ::SUnitRange{Start, L}) where {Start, L}
+function show(io::IO, ::SUnitRange{Start, L}) where {Start, L}
     print(io, "SUnitRange($Start,$(Start + L - 1))")
 end
+
+# Shorten show for REPL use.
+show(io::IO, ::MIME"text/plain", su::SUnitRange) = show(io, su)

src/SVector.jl

@@ -36,10 +36,6 @@ const SVector{S, T} = SArray{Tuple{S}, T, 1, S}
 ## SVector methods ##
 #####################
 
-@propagate_inbounds function getindex(v::SVector, i::Int)
-    v.data[i]
-end
-
 # Converting a CartesianIndex to an SVector
 convert(::Type{SVector}, I::CartesianIndex) = SVector(I.I)
 convert(::Type{SVector{N}}, I::CartesianIndex{N}) where {N} = SVector{N}(I.I)
@@ -117,3 +113,4 @@ macro SVector(ex)
         error("Use @SVector [a,b,c], @SVector Type[a,b,c] or a comprehension like [f(i) for i = i_min:i_max]")
     end
 end
+

src/SizedArray.jl

@@ -33,9 +33,7 @@ struct SizedArray{S<:Tuple,T,N,M,TData<:AbstractArray{T,M}} <: StaticArray{S,T,N
 end
 
 # Julia v1.0 has some weird bug that prevents this from working
-@static if VERSION >= v"1.1"
-    @inline SizedArray(a::StaticArray{S,T,N}) where {S<:Tuple,T,N} = SizedArray{S,T,N}(a)
-end
+@inline SizedArray(a::StaticArray{S,T,N}) where {S<:Tuple,T,N} = SizedArray{S,T,N}(a)
 @inline function SizedArray{S,T,N}(
     a::TData,
 ) where {S,T,N,M,TData<:AbstractArray{T,M}}
@@ -151,10 +149,7 @@ end
 
 const SizedMatrix{S1,S2,T} = SizedArray{Tuple{S1,S2},T,2}
 
-# Julia v1.0 has some weird bug that prevents this from working
-@static if VERSION >= v"1.1"
-    SizedMatrix(a::StaticMatrix{N,M,T}) where {N,M,T} = SizedMatrix{N,M,T}(a)
-end
+SizedMatrix(a::StaticMatrix{N,M,T}) where {N,M,T} = SizedMatrix{N,M,T}(a)
 @inline function SizedMatrix{S1,S2}(
     a::TData,
 ) where {S1,S2,T,M,TData<:AbstractArray{T,M}}