Merge branch 'master' of https://github.com/JuliaArrays/StaticArrays.jl into mbaran/matmul-symmetric

mateuszbaran · mateuszbaran · commit 246c256b31e8 · 2020-08-13T17:47:13.000+02:00
diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
@@ -10,7 +10,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@latest
         with:
-          version: 1.3
+          version: 1.4
       - name: Install dependencies
         run: julia -e 'using Pkg; pkg"add PkgBenchmark BenchmarkCI@0.1"'
       - name: Run benchmarks
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -9,13 +9,15 @@ jobs:
   test:
     name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }}
     runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.version == 'nightly' }}
     strategy:
       matrix:
         version:
           - '1.0'
           - '1.1'
           - '1.2'
           - '1.3'
+          - '1.4'
           - 'nightly'
         os:
           - ubuntu-latest
@@ -32,8 +34,10 @@ jobs:
           # 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
@@ -52,7 +56,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: julia-actions/setup-julia@latest
         with:
-          version: '1.3'
+          version: '1.4'
       - run: julia --project=docs -e '
           using Pkg;
           Pkg.develop(PackageSpec(; path=pwd()));
diff --git a/Project.toml b/Project.toml
@@ -1,6 +1,6 @@
 name = "StaticArrays"
 uuid = "90137ffa-7385-5640-81b9-e52037218182"
-version = "0.12.2"
+version = "0.12.4"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -11,9 +11,9 @@ Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 julia = "1"
 
 [extras]
+BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
 
 [targets]
 test = ["InteractiveUtils", "Test", "BenchmarkTools"]
diff --git a/src/SArray.jl b/src/SArray.jl
@@ -50,6 +50,62 @@ end
     end
 end
 
+
+@noinline function generator_too_short_error(inds::CartesianIndices, i::CartesianIndex)
+    error("Generator produced too few elements: Expected exactly $(shape_string(inds)) elements, but generator stopped at $(shape_string(i))")
+end
+@noinline function generator_too_long_error(inds::CartesianIndices)
+    error("Generator produced too many elements: Expected exactly $(shape_string(inds)) elements, but generator yields more")
+end
+
+shape_string(inds::CartesianIndices) = join(length.(inds.indices), '×')
+shape_string(inds::CartesianIndex) = join(Tuple(inds), '×')
+
+@inline throw_if_nothing(x, inds, i) =
+    (x === nothing && generator_too_short_error(inds, i); x)
+
+@generated function sacollect(::Type{SA}, gen) where {SA <: StaticArray{S}} where {S <: Tuple}
+    stmts = [:(Base.@_inline_meta)]
+    args = []
+    iter = :(iterate(gen))
+    inds = CartesianIndices(size_to_tuple(S))
+    for i in inds
+        el = Symbol(:el, i)
+        push!(stmts, :(($el,st) = throw_if_nothing($iter, $inds, $i)))
+        push!(args, el)
+        iter = :(iterate(gen,st))
+    end
+    push!(stmts, :($iter === nothing || generator_too_long_error($inds)))
+    push!(stmts, :(SA($(args...))))
+    Expr(:block, stmts...)
+end
+"""
+   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)
+
+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])
+"""
+sacollect
+
+@inline (::Type{SA})(gen::Base.Generator) where {SA <: StaticArray} =
+    sacollect(SA, gen)
+
 @inline SArray(a::StaticArray) = SArray{size_tuple(Size(a))}(Tuple(a))
 
 ####################
@@ -66,7 +122,7 @@ Base.dataids(::SArray) = ()
 
 # See #53
 Base.cconvert(::Type{Ptr{T}}, a::SArray) where {T} = Base.RefValue(a)
-Base.unsafe_convert(::Type{Ptr{T}}, a::Base.RefValue{SArray{S,T,D,L}}) where {S,T,D,L} =
+Base.unsafe_convert(::Type{Ptr{T}}, a::Base.RefValue{SA}) where {S,T,D,L,SA<:SArray{S,T,D,L}} =
     Ptr{T}(Base.unsafe_convert(Ptr{SArray{S,T,D,L}}, a))
 
 macro SArray(ex)
diff --git a/src/SMatrix.jl b/src/SMatrix.jl
@@ -52,6 +52,11 @@ end
     end
 end
 
+@inline SMatrix{M, N, T}(gen::Base.Generator) where {M, N, T} =
+    sacollect(SMatrix{M, N, T}, gen)
+@inline SMatrix{M, N}(gen::Base.Generator) where {M, N} =
+    sacollect(SMatrix{M, N}, gen)
+
 @inline convert(::Type{SMatrix{S1,S2}}, a::StaticArray{<:Tuple, T}) where {S1,S2,T} = SMatrix{S1,S2,T}(Tuple(a))
 @inline SMatrix(a::StaticMatrix{S1, S2}) where {S1, S2} = SMatrix{S1, S2}(Tuple(a))
 
diff --git a/src/SOneTo.jl b/src/SOneTo.jl
@@ -15,6 +15,8 @@ function SOneTo{n}(r::AbstractUnitRange) where n
     errmsg(r)
 end
 
+Base.Tuple(::SOneTo{N}) where N = ntuple(identity, Val(N))
+
 Base.axes(s::SOneTo) = (s,)
 Base.size(s::SOneTo) = (length(s),)
 Base.length(s::SOneTo{n}) where {n} = n
diff --git a/src/SVector.jl b/src/SVector.jl
@@ -19,6 +19,11 @@ const SVector{S, T} = SArray{Tuple{S}, T, 1, S}
 @inline SVector{S}(x::NTuple{S,T}) where {S, T} = SVector{S,T}(x)
 @inline SVector{S}(x::T) where {S, T <: Tuple} = SVector{S,promote_tuple_eltype(T)}(x)
 
+@inline SVector{N, T}(gen::Base.Generator) where {N, T} =
+    sacollect(SVector{N, T}, gen)
+@inline SVector{N}(gen::Base.Generator) where {N} =
+    sacollect(SVector{N}, gen)
+
 # conversion from AbstractVector / AbstractArray (better inference than default)
 #@inline convert{S,T}(::Type{SVector{S}}, a::AbstractArray{T}) = SVector{S,T}((a...))
 
diff --git a/src/abstractarray.jl b/src/abstractarray.jl
@@ -185,7 +185,11 @@ reshape(a::Array, ::Size{S}) where {S} = SizedArray{Tuple{S...}}(a)
 @inline copy(a::StaticArray) = typeof(a)(Tuple(a))
 @inline copy(a::SizedArray) = typeof(a)(copy(a.data))
 
-@inline reverse(v::StaticVector) = typeof(v)(reverse(Tuple(v)))
+@inline reverse(v::StaticVector) = typeof(v)(_reverse(v))
+
+@generated function _reverse(v::StaticVector{N,T}) where {N,T}
+    return Expr(:tuple, (:(v[$i]) for i = N:(-1):1)...)
+end
 
 # TODO permutedims?
 
diff --git a/src/convert.jl b/src/convert.jl
@@ -8,6 +8,7 @@
 
 # this covers most conversions and "statically-sized reshapes"
 @inline convert(::Type{SA}, sa::StaticArray) where {SA<:StaticArray} = SA(Tuple(sa))
+@inline convert(::Type{SA}, sa::StaticArray) where {SA<:Scalar} = SA((sa[],)) # disambiguation
 @inline convert(::Type{SA}, sa::SA) where {SA<:StaticArray} = sa
 @inline convert(::Type{SA}, x::Tuple) where {SA<:StaticArray} = SA(x) # convert -> constructor. Hopefully no loops...
 
diff --git a/src/mapreduce.jl b/src/mapreduce.jl
@@ -113,6 +113,17 @@ end
 @inline _mapreduce(args::Vararg{Any,N}) where N = _mapfoldl(args...)
 
 @generated function _mapfoldl(f, op, dims::Colon, init, ::Size{S}, a::StaticArray...) where {S}
+    if prod(S) == 0
+        if init === _InitialValue
+            if length(a) == 1
+                return :(Base.mapreduce_empty(f, op, $(eltype(a[1]))))
+            else
+                return :(throw(ArgumentError("reducing over an empty collection is not allowed")))
+            end
+        else
+            return :init
+        end
+    end
     tmp = [:(a[$j][1]) for j ∈ 1:length(a)]
     expr = :(f($(tmp...)))
     if init === _InitialValue
@@ -291,8 +302,8 @@ end
 
     return quote
         @_inline_meta
-        T = typeof(one(eltype(a)) - one(eltype(a)))
-        @inbounds return similar_type(a, T, Size($Snew))(tuple($(exprs...)))
+        elements = tuple($(exprs...))
+        @inbounds return similar_type(a, eltype(elements), Size($Snew))(elements)
     end
 end
 
diff --git a/src/sort.jl b/src/sort.jl
@@ -1,5 +1,5 @@
-import Base.Order: Ordering, Forward, ReverseOrdering, ord
-import Base.Sort: Algorithm, lt, sort
+import Base.Order: Forward, Ordering, Perm, ReverseOrdering, ord
+import Base.Sort: Algorithm, lt, sort, sortperm
 
 
 struct BitonicSortAlg <: Algorithm end
@@ -23,20 +23,36 @@ defalg(a::StaticVector) =
     return _sort(a, alg, ordr)
 end
 
+@inline function sortperm(a::StaticVector;
+               alg::Algorithm = defalg(a),
+               lt = isless,
+               by = identity,
+               rev::Union{Bool,Nothing} = nothing,
+               order::Ordering = Forward)
+    p = Tuple(axes(a, 1))
+    length(a) <= 1 && return SVector{length(a),Int}(p)
+
+    ordr = Perm(ord(lt, by, rev, order), a)
+    return SVector{length(a),Int}(_sort(p, alg, ordr))
+end
+
+
 @inline _sort(a::StaticVector, alg, order) =
     similar_type(a)(sort!(Base.copymutable(a); alg=alg, order=order))
 
 @inline _sort(a::StaticVector, alg::BitonicSortAlg, order) =
     similar_type(a)(_sort(Tuple(a), alg, order))
 
+_sort(a::NTuple, alg, order) = sort!(Base.copymutable(a); alg=alg, order=order)
+
 # Implementation loosely following
 # https://www.inf.hs-flensburg.de/lang/algorithmen/sortieren/bitonic/oddn.htm
 @generated function _sort(a::NTuple{N}, ::BitonicSortAlg, order) where N
     function swap_expr(i, j, rev)
         ai = Symbol('a', i)
         aj = Symbol('a', j)
         order = rev ? :revorder : :order
-        return :( ($ai, $aj) = lt($order, $ai, $aj) ? ($ai, $aj) : ($aj, $ai) )
+        return :( ($ai, $aj) = @inbounds lt($order, $ai, $aj) ? ($ai, $aj) : ($aj, $ai) )
     end
 
     function merge_exprs(idx, rev)
diff --git a/src/svd.jl b/src/svd.jl
@@ -37,7 +37,9 @@ function svd(A::StaticMatrix; full=Val(false))
 end
 
 # Allow plain Bool in addition to Val
-_svd(A, full) = _svd(A, Val(convert(Bool, full)))
+# Required inline as of version 1.5 to ensure Bool usage like svd(A,
+# full=false) is constant-propagated
+@inline _svd(A, full) = _svd(A, Val(convert(Bool, full)))
 
 function _svd(A, full::Val{false})
     f = svd(Matrix(A), full=false)
diff --git a/src/traits.jl b/src/traits.jl
@@ -129,9 +129,6 @@ Length(::Size{S}) where {S} = _Length(S...)
 @pure Base.:(==)(::Size{S}, s::Tuple{Vararg{Int}}) where {S} = S === s
 @pure Base.:(==)(s::Tuple{Vararg{Int}}, ::Size{S}) where {S} = s === S
 
-@pure Base.:(!=)(::Size{S}, s::Tuple{Vararg{Int}}) where {S} = S !== s
-@pure Base.:(!=)(s::Tuple{Vararg{Int}}, ::Size{S}) where {S} = s !== S
-
 @pure Base.prod(::Size{S}) where {S} = prod(S)
 
 Base.LinearIndices(::Size{S}) where {S} = LinearIndices(S)
@@ -144,9 +141,6 @@ Base.LinearIndices(::Size{S}) where {S} = LinearIndices(S)
 @pure Base.:(==)(::Length{L}, l::Int) where {L} = L == l
 @pure Base.:(==)(l::Int, ::Length{L}) where {L} = l == L
 
-@pure Base.:(!=)(::Length{L}, l::Int) where {L} = L != l
-@pure Base.:(!=)(l::Int, ::Length{L}) where {L} = l != L
-
 # unroll_tuple also works with `Length`
 @propagate_inbounds unroll_tuple(f, ::Length{L}) where {L} = unroll_tuple(f, Val{L})
 
diff --git a/test/MArray.jl b/test/MArray.jl
@@ -32,6 +32,29 @@
         v = MArray{Tuple{2}}(1,2)
         @test MArray(v) !== v && MArray(v) == v
 
+        @test MArray{Tuple{}}(i for i in 1:1).data === (1,)
+        @test MArray{Tuple{3}}(i for i in 1:3).data === (1,2,3)
+        @test MArray{Tuple{3}}(float(i) for i in 1:3).data === (1.0,2.0,3.0)
+        @test MArray{Tuple{2,3}}(i+10j for i in 1:2, j in 1:3).data === (11,12,21,22,31,32)
+        @test MArray{Tuple{1,2,3}}(i+10j+100k for i in 1:1, j in 1:2, k in 1:3).data === (111,121,211,221,311,321)
+        @test_throws Exception MArray{Tuple{}}(i for i in 1:0)
+        @test_throws Exception MArray{Tuple{}}(i for i in 1:2)
+        @test_throws Exception MArray{Tuple{3}}(i for i in 1:2)
+        @test_throws Exception MArray{Tuple{3}}(i for i in 1:4)
+        @test_throws Exception MArray{Tuple{2,3}}(10i+j for i in 1:1, j in 1:3)
+        @test_throws Exception MArray{Tuple{2,3}}(10i+j for i in 1:3, j in 1:3)
+
+        @test StaticArrays.sacollect(MVector{6}, Iterators.product(1:2, 1:3)) ==
+            MVector{6}(collect(Iterators.product(1:2, 1:3)))
+        @test StaticArrays.sacollect(MVector{2}, Iterators.zip(1:2, 2:3)) ==
+            MVector{2}(collect(Iterators.zip(1:2, 2:3)))
+        @test StaticArrays.sacollect(MVector{3}, Iterators.take(1:10, 3)) ==
+            MVector{3}(collect(Iterators.take(1:10, 3)))
+        @test StaticArrays.sacollect(MMatrix{2,3}, Iterators.product(1:2, 1:3)) ==
+            MMatrix{2,3}(collect(Iterators.product(1:2, 1:3)))
+        @test StaticArrays.sacollect(MArray{Tuple{2,3,4}}, 1:24) ==
+            MArray{Tuple{2,3,4}}(collect(1:24))
+
         @test ((@MArray [1])::MArray{Tuple{1}}).data === (1,)
         @test ((@MArray [1,2])::MArray{Tuple{2}}).data === (1,2)
         @test ((@MArray Float64[1,2,3])::MArray{Tuple{3}}).data === (1.0, 2.0, 3.0)
diff --git a/test/SArray.jl b/test/SArray.jl
@@ -27,6 +27,29 @@
 
         @test SArray(SArray{Tuple{2}}(1,2)) === SArray{Tuple{2}}(1,2)
 
+        @test SArray{Tuple{}}(i for i in 1:1).data === (1,)
+        @test SArray{Tuple{3}}(i for i in 1:3).data === (1,2,3)
+        @test SArray{Tuple{3}}(float(i) for i in 1:3).data === (1.0,2.0,3.0)
+        @test SArray{Tuple{2,3}}(i+10j for i in 1:2, j in 1:3).data === (11,12,21,22,31,32)
+        @test SArray{Tuple{1,2,3}}(i+10j+100k for i in 1:1, j in 1:2, k in 1:3).data === (111,121,211,221,311,321)
+        @test_throws Exception SArray{Tuple{}}(i for i in 1:0)
+        @test_throws Exception SArray{Tuple{}}(i for i in 1:2)
+        @test_throws Exception SArray{Tuple{3}}(i for i in 1:2)
+        @test_throws Exception SArray{Tuple{3}}(i for i in 1:4)
+        @test_throws Exception SArray{Tuple{2,3}}(10i+j for i in 1:1, j in 1:3)
+        @test_throws Exception SArray{Tuple{2,3}}(10i+j for i in 1:3, j in 1:3)
+
+        @test StaticArrays.sacollect(SVector{6}, Iterators.product(1:2, 1:3)) ==
+            SVector{6}(collect(Iterators.product(1:2, 1:3)))
+        @test StaticArrays.sacollect(SVector{2}, Iterators.zip(1:2, 2:3)) ==
+            SVector{2}(collect(Iterators.zip(1:2, 2:3)))
+        @test StaticArrays.sacollect(SVector{3}, Iterators.take(1:10, 3)) ==
+            SVector{3}(collect(Iterators.take(1:10, 3)))
+        @test StaticArrays.sacollect(SMatrix{2,3}, Iterators.product(1:2, 1:3)) ==
+            SMatrix{2,3}(collect(Iterators.product(1:2, 1:3)))
+        @test StaticArrays.sacollect(SArray{Tuple{2,3,4}}, 1:24) ==
+            SArray{Tuple{2,3,4}}(collect(1:24))
+
         @test ((@SArray [1])::SArray{Tuple{1}}).data === (1,)
         @test ((@SArray [1,2])::SArray{Tuple{2}}).data === (1,2)
         @test ((@SArray Float64[1,2,3])::SArray{Tuple{3}}).data === (1.0, 2.0, 3.0)
diff --git a/test/SMatrix.jl b/test/SMatrix.jl
@@ -26,6 +26,22 @@
         @test SMatrix{2}((1,2,3,4)).data === (1,2,3,4)
         @test_throws DimensionMismatch SMatrix{2}((1,2,3,4,5))
 
+        @test (SMatrix{2,3}(i+10j for i in 1:2, j in 1:3)::SMatrix{2,3}).data ===
+            (11,12,21,22,31,32)
+        @test (SMatrix{2,3}(float(i+10j) for i in 1:2, j in 1:3)::SMatrix{2,3}).data ===
+            (11.0,12.0,21.0,22.0,31.0,32.0)
+        @test (SMatrix{0,0,Int}()::SMatrix{0,0}).data === ()
+        @test (SMatrix{0,3,Int}()::SMatrix{0,3}).data === ()
+        @test (SMatrix{2,0,Int}()::SMatrix{2,0}).data === ()
+        @test (SMatrix{2,3,Int}(i+10j for i in 1:2, j in 1:3)::SMatrix{2,3}).data ===
+            (11,12,21,22,31,32)
+        @test (SMatrix{2,3,Float64}(i+10j for i in 1:2, j in 1:3)::SMatrix{2,3}).data ===
+            (11.0,12.0,21.0,22.0,31.0,32.0)
+        @test_throws Exception SMatrix{2,3}(i+10j for i in 1:1, j in 1:3)
+        @test_throws Exception SMatrix{2,3}(i+10j for i in 1:3, j in 1:3)
+        @test_throws Exception SMatrix{2,3,Int}(i+10j for i in 1:1, j in 1:3)
+        @test_throws Exception SMatrix{2,3,Int}(i+10j for i in 1:3, j in 1:3)
+
         @test ((@SMatrix [1.0])::SMatrix{1,1}).data === (1.0,)
         @test ((@SMatrix [1 2])::SMatrix{1,2}).data === (1, 2)
         @test ((@SMatrix [1 ; 2])::SMatrix{2,1}).data === (1, 2)
diff --git a/test/SVector.jl b/test/SVector.jl
@@ -16,6 +16,16 @@
         @test SVector((1,)).data === (1,)
         @test SVector((1.0,)).data === (1.0,)
 
+        @test SVector{3}(i for i in 1:3).data === (1,2,3)
+        @test SVector{3}(float(i) for i in 1:3).data === (1.0,2.0,3.0)
+        @test SVector{0,Int}().data === ()
+        @test SVector{3,Int}(i for i in 1:3).data === (1,2,3)
+        @test SVector{3,Float64}(i for i in 1:3).data === (1.0,2.0,3.0)
+        @test_throws Exception SVector{3}(i for i in 1:2)
+        @test_throws Exception SVector{3}(i for i in 1:4)
+        @test_throws Exception SVector{3,Int}(i for i in 1:2)
+        @test_throws Exception SVector{3,Int}(i for i in 1:4)
+
         @test SVector(1).data === (1,)
         @test SVector(1,1.0).data === (1.0,1.0)
 
diff --git a/test/ambiguities.jl b/test/ambiguities.jl
diff --git a/test/convert.jl b/test/convert.jl
diff --git a/test/mapreduce.jl b/test/mapreduce.jl
diff --git a/test/sort.jl b/test/sort.jl
diff --git a/test/svd.jl b/test/svd.jl
