Merge branch 'JuliaArrays:master' into master

Author: astrozot

.github/workflows/Invalidations.yml

@@ -36,5 +36,7 @@ jobs:
         echo "Invalidations on default branch: ${{ steps.invs_default.outputs.total }} (${{ steps.invs_default.outputs.deps }} via deps)" >> $GITHUB_STEP_SUMMARY
         echo "This branch: ${{ steps.invs_pr.outputs.total }} (${{ steps.invs_pr.outputs.deps }} via deps)" >> $GITHUB_STEP_SUMMARY
     - name: Check if the PR does increase number of invalidations
-      if: steps.invs_pr.outputs.total > steps.invs_default.outputs.total
-      run: exit 1
+      run: |
+        if [ ${{ steps.invs_pr.outputs.total }} -gt ${{ steps.invs_default.outputs.total }} ]; then
+          exit 1
+        fi

Project.toml

@@ -1,6 +1,6 @@
 name = "StaticArrays"
 uuid = "90137ffa-7385-5640-81b9-e52037218182"
-version = "1.9.6"
+version = "1.9.7"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

docs/make.jl

@@ -3,7 +3,9 @@ using StaticArrays
 using StaticArraysCore
 
 # Setup for doctests in docstrings
-DocMeta.setdocmeta!(StaticArrays, :DocTestSetup, :(using LinearAlgebra, StaticArrays))
+doctest_setup = :(using LinearAlgebra, StaticArrays)
+DocMeta.setdocmeta!(StaticArrays,     :DocTestSetup, doctest_setup)
+DocMeta.setdocmeta!(StaticArraysCore, :DocTestSetup, doctest_setup)
 
 makedocs(;
     modules = [StaticArrays, StaticArraysCore],
@@ -13,8 +15,8 @@ makedocs(;
     ),
     pages = [
         "Home" => "index.md",
-        "API" => "pages/api.md",
-        "Quick Start" => "pages/quickstart.md",
+        "API" => "api.md",
+        "Quick Start" => "quickstart.md",
         ],
     sitename = "StaticArrays.jl",
 )

docs/src/pages/api.md docs/src/api.mddocs/src/pages/api.md renamed to docs/src/api.md

@@ -140,7 +140,7 @@ additional loop unrolling and inlining, and consequentially (c) their mutating
 methods like `map!` are extremely fast. Benchmarking shows that operations such
 as addition and matrix multiplication are faster for `MMatrix` than `Matrix`,
 at least for sizes up to 14 × 14, though keep in mind that optimal speed will
-be obtained by using mutating functions (like `map!` or `A_mul_B!`) where
+be obtained by using mutating functions (like `map!` or `mul!`) where
 possible, rather than reallocating new memory.
 
 Mutable static arrays also happen to be very useful containers that can be
@@ -247,12 +247,14 @@ could be represented as a `Vector{SVector{3,Float64}}`.
 Another common way of storing the same data is as a 3×`N` `Matrix{Float64}`.
 Rather conveniently, such types have *exactly* the same binary layout in memory,
 and therefore we can use `reinterpret` to convert between the two formats
-```julia
+```@example copy
+using StaticArrays # hide
 function svectors(x::Matrix{T}, ::Val{N}) where {T,N}
     size(x,1) == N || error("sizes mismatch")
     isbitstype(T) || error("use for bitstypes only")
     reinterpret(SVector{N,T}, vec(x))
 end
+nothing # hide
 ```
 Such a conversion does not copy the data, rather it refers to the *same* memory.
 Arguably, a `Vector` of `SVector`s is often preferable to a `Matrix` because it
@@ -263,31 +265,19 @@ However, the resulting object is a Base.ReinterpretArray, not an Array, which
 carries some runtime penalty on every single access. If you can afford the
 memory for a copy and can live with the non-shared mutation semantics, then it
 is better to pull a copy by e.g.
-```julia
+```@example copy
 function svectorscopy(x::Matrix{T}, ::Val{N}) where {T,N}
     size(x,1) == N || error("sizes mismatch")
     isbitstype(T) || error("use for bitstypes only")
     copy(reinterpret(SVector{N,T}, vec(x)))
 end
+nothing # hide
 ```
 For example:
-```
-julia> M=reshape(collect(1:6), (2,3))
-2×3 Array{Int64,2}:
- 1  3  5
- 2  4  6
-
-julia> svectors(M, Val{2}())
-3-element reinterpret(SArray{Tuple{2},Int64,1,2}, ::Array{Int64,1}):
- [1, 2]
- [3, 4]
- [5, 6]
-
-julia> svectorscopy(M, Val{2}())
-3-element Array{SArray{Tuple{2},Int64,1,2},1}:
- [1, 2]
- [3, 4]
- [5, 6]
+```@repl copy
+M = reshape(collect(1:6), (2,3))
+svectors(M, Val{2}())
+svectorscopy(M, Val{2}())
 ```
 
 ### Working with mutable and immutable arrays

docs/src/pages/quickstart.md docs/src/quickstart.mddocs/src/pages/quickstart.md renamed to docs/src/quickstart.md

@@ -1,6 +1,7 @@
 # Quick Start
 
 ```julia
+import Pkg
 Pkg.add("StaticArrays")  # or Pkg.clone("https://github.com/JuliaArrays/StaticArrays.jl")
 using StaticArrays
 using LinearAlgebra

src/SArray.jl

@@ -28,26 +28,29 @@ shape_string(inds::CartesianIndex) = join(Tuple(inds), '×')
     Expr(:block, stmts...)
 end
 """
-   sacollect(SA, gen)
+    sacollect(SA, gen)
 
 Construct a statically-sized vector of type `SA`.from a generator
 `gen`. `SA` needs to have a size parameter since the length of `vec`
 is unknown to the compiler. `SA` can optionally specify the element
 type as well.
 
 Example:
-
-    sacollect(SVector{3, Int}, 2i+1 for i in 1:3)
-    sacollect(SMatrix{2, 3}, i+j for i in 1:2, j in 1:3)
-    sacollect(SArray{2, 3}, i+j for i in 1:2, j in 1:3)
+```julia
+sacollect(SVector{3, Int}, 2i+1 for i in 1:3)
+sacollect(SMatrix{2, 3}, i+j for i in 1:2, j in 1:3)
+sacollect(SArray{2, 3}, i+j for i in 1:2, j in 1:3)
+```
 
 This creates the same statically-sized vector as if the generator were
 collected in an array, but is more efficient since no array is
 allocated.
 
 Equivalent:
 
-    SVector{3, Int}([2i+1 for i in 1:3])
+```julia
+SVector{3, Int}([2i+1 for i in 1:3])
+```
 """
 sacollect
 
@@ -304,19 +307,19 @@ end
 A convenience macro to construct `SArray` with arbitrary dimension.
 It supports:
 1. (typed) array literals.
-!!! note
-    Every argument inside the square brackets is treated as a scalar during expansion.
-    Thus `@SArray[a; b]` always forms a `SVector{2}` and `@SArray [a b; c]` always throws
-    an error.
+   !!! note
+       Every argument inside the square brackets is treated as a scalar during expansion.
+       Thus `@SArray[a; b]` always forms a `SVector{2}` and `@SArray [a b; c]` always throws
+       an error.
 
 2. comprehensions
-!!! note
-    The range of a comprehension is evaluated at global scope by the macro, and must be
-    made of combinations of literal values, functions, or global variables.
+   !!! note
+       The range of a comprehension is evaluated at global scope by the macro, and must be
+       made of combinations of literal values, functions, or global variables.
 
 3. initialization functions
-!!! note
-    Only support `zeros()`, `ones()`, `fill()`, `rand()`, `randn()`, and `randexp()`
+   !!! note
+       Only support `zeros()`, `ones()`, `fill()`, `rand()`, `randn()`, and `randexp()`
 """
 macro SArray(ex)
     static_array_gen(SArray, ex, __module__)

src/StaticArrays.jl

@@ -16,7 +16,8 @@ using LinearAlgebra
 import LinearAlgebra: transpose, adjoint, dot, eigvals, eigen, lyap, tr,
                       kron, diag, norm, dot, diagm, lu, svd, svdvals, pinv,
                       factorize, ishermitian, issymmetric, isposdef, issuccess, normalize,
-                      normalize!, Eigen, det, logdet, logabsdet, cross, diff, qr, \
+                      normalize!, Eigen, det, logdet, logabsdet, cross, diff, qr, \,
+                      triu, tril
 using LinearAlgebra: checksquare
 
 using PrecompileTools

src/arraymath.jl

@@ -182,7 +182,7 @@ end
 """
     arithmetic_closure(T)
 
-Return the type which values of type `T` will promote to under a combination of the arithmetic operations `+, -, *` and `/`.
+Return the type which values of type `T` will promote to under a combination of the arithmetic operations `+`, `-`, `*` and `/`.
 
 ```jldoctest
 julia> import StaticArrays.arithmetic_closure

src/convert.jl

@@ -60,21 +60,29 @@ The adaption rules for official `StaticArray`s could be summarized as:
 
 # `SA <: Union{SArray, MArray, SHermitianCompact, SizedArray}`: `size`/`eltype` adaptable
 
-- SA(x::Tuple)
- If `SA` is fully static-sized, then we first try to fill `SA` with `x`'s elements.
- If failed and `length(SA) == 1`, then we try to fill `SA` with `x` itself.
-
- If `SA` is not fully static-sized, then we always try to fill `SA` with `x`'s elements,
- and the constructor's `Size` is derived based on:
- 1. If `SA <: StaticVector`, then we use `length(x)` as the output `Length` 
- 2. If `SA <: StaticMatrix{M}`, then we use `(M, N)` (`N = length(x) ÷ M`) as the output `Size`
- 3. If `SA <: StaticMatrix{M,M} where M`, then we use `(N, N)` (`N = sqrt(length(x)`) as the output `Size`.
-- SA(x...)
- Similar to `Tuple`, but we never fill `SA` with `x` itself.
-- SA(x::StaticArray)
- We treat `x` as `Tuple` whenever possible. If failed, then try to inherit `x`'s `Size`.
-- SA(x::AbstractArray)
- `x` is used to provide eltype. Thus `SA` must be static sized.
+- `SA(x::Tuple)`
+
+  If `SA` is fully static-sized, then we first try to fill `SA` with `x`'s elements.
+  If failed and `length(SA) == 1`, then we try to fill `SA` with `x` itself.
+
+  If `SA` is not fully static-sized, then we always try to fill `SA` with `x`'s elements,
+  and the constructor's `Size` is derived based on:
+  1. If `SA <: StaticVector`, then we use `length(x)` as the output `Length`
+  2. If `SA <: StaticMatrix{M}`, then we use `(M, N)` (`N = length(x) ÷ M`) as the output `Size`
+  3. If `SA <: StaticMatrix{M,M} where M`, then we use `(N, N)` (`N = sqrt(length(x)`) as the output `Size`.
+
+- `SA(x...)`
+
+  Similar to `Tuple`, but we never fill `SA` with `x` itself.
+
+- `SA(x::StaticArray)`
+
+  We treat `x` as `Tuple` whenever possible. If failed, then try to inherit `x`'s `Size`.
+
+- `SA(x::AbstractArray)`
+
+  `x` is used to provide eltype. Thus `SA` must be static sized.
+
 """
 function construct_type(::Type{SA}, x) where {SA<:StaticArray}
     x isa BadArgs || return SA

src/initializers.jl

@@ -9,8 +9,8 @@ provided explicitly.
 # Examples:
 
 * `SA[1.0, 2.0]` creates a length-2 `SVector` of `Float64` elements.
-* `SA[1 2; 3 4]` creates a 2×2 SMatrix of `Int`s.
-* `SA[1 2]` creates a 1×2 SMatrix of `Int`s.
+* `SA[1 2; 3 4]` creates a 2×2 `SMatrix` of `Int`s.
+* `SA[1 2]` creates a 1×2 `SMatrix` of `Int`s.
 * `SA{Float32}[1, 2]` creates a length-2 `SVector` of `Float32` elements.
 
 A couple of helpful type aliases are also provided: