Add support for arrays of StaticArrays and use Requires

Using Requires reduces package load time a bit when StaticArrays and
StatsBase are not used.

Author: oschulz

REQUIRE

@@ -1,4 +1,3 @@
 julia 0.7
 Requires
-StatsBase
 UnsafeArrays

src/ArraysOfArrays.jl

@@ -4,15 +4,20 @@ __precompile__(true)
 
 module ArraysOfArrays
 
+using Requires
 using Statistics
-
 using UnsafeArrays
 
-import StatsBase
-
 include("util.jl")
 include("functions.jl")
 include("array_of_similar_arrays.jl")
 include("vector_of_arrays.jl")
 
+
+function __init__()
+    @require StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" include("staticarrays_support.jl")
+    @require StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" include("statsbase_support.jl")
+end
+
+
 end # module

src/array_of_similar_arrays.jl

@@ -371,7 +371,6 @@ Compute the sum of the elements vectors of `X`. Equivalent to `sum` of
 `flatview(X)` along the last dimension.
 """
 Base.sum(X::AbstractVectorOfSimilarArrays{T,M}) where {T,M} = sum(flatview(X); dims = M + 1)
-Base.sum(X::AbstractVectorOfSimilarArrays{T,M}, w::StatsBase.AbstractWeights) where {T,M} = sum(flatview(X), w, M + 1)
 
 
 """
@@ -383,8 +382,6 @@ Compute the mean of the elements vectors of `X`. Equivalent to `mean` of
 """
 Statistics.mean(X::AbstractVectorOfSimilarArrays{T,M}) where {T,M} =
     mean(flatview(X); dims = M + 1)
-Statistics.mean(X::AbstractVectorOfSimilarArrays{T,M}, w::StatsBase.AbstractWeights) where {T,M} =
-    mean(flatview(X), w, M + 1)
 
 
 """
@@ -396,8 +393,6 @@ Compute the sample variance of the elements vectors of `X`. Equivalent to
 """
 Statistics.var(X::AbstractVectorOfSimilarArrays{T,M}; corrected::Bool = true) where {T,M} =
     var(flatview(X); dims = M + 1, corrected = corrected)
-Statistics.var(X::AbstractVectorOfSimilarArrays{T,M}, w::StatsBase.AbstractWeights; corrected::Bool = true) where {T,M} =
-    var(flatview(X), w, M + 1; corrected = corrected)
 
 
 """
@@ -409,8 +404,6 @@ along `X`. Equivalent to `cov` of `flatview(X)` along dimension 2.
 """
 Statistics.cov(X::AbstractVectorOfSimilarVectors; corrected::Bool = true) =
     cov(flatview(X); dims = 2, corrected = corrected)
-Statistics.cov(X::AbstractVectorOfSimilarVectors, w::StatsBase.AbstractWeights; corrected::Bool = true) =
-    cov(flatview(X), w, 2; corrected = corrected)
 
 
 """
@@ -422,5 +415,3 @@ Compute the Pearson correlation matrix between the elements of the elements of
 """
 Statistics.cor(X::AbstractVectorOfSimilarVectors) =
     cor(flatview(X); dims = 2)
-Statistics.cor(X::AbstractVectorOfSimilarVectors, w::StatsBase.AbstractWeights) =
-    cor(flatview(X), w, 2)

src/functions.jl

@@ -57,6 +57,12 @@ AbstractArray{<:AbstractArray{T,M},N}
 
 View array `A` in as an `M`-dimensional array of `N`-dimensional arrays by
 wrapping it into an [`ArrayOfSimilarArrays`](@ref).
+
+It's also possible to use a `StaticVector` of length `S` as the type of the
+inner arrays via
+
+    nestedview(A::AbstractArray{T}, ::Type{StaticArrays.SVector{S}})
+    nestedview(A::AbstractArray{T}, ::Type{StaticArrays.SVector{S,T}})
 """
 function nestedview end
 export nestedview

src/staticarrays_support.jl

@@ -0,0 +1,15 @@
+# This file is a part of ArraysOfArrays.jl, licensed under the MIT License (MIT).
+
+
+@inline flatview(A::AbstractArray{SA,N}) where {S,T,M,N,SA<:StaticArrays.StaticArray{S,T,M}} =
+    reshape(reinterpret(T, A), size(SA)..., size(A)...)
+
+
+@inline function nestedview(A::AbstractArray{T}, SA::Type{StaticArrays.SVector{S,T}}) where {T,S}
+    size_A = size(A)
+    size_A[1] == S || throw(DimensionMismatch("Length $S of static vector type does not match first dimension of array of size $size_A"))
+    reshape(reinterpret(SA, A), _tail(size_A)...)
+end
+
+@inline nestedview(A::AbstractArray{T}, ::Type{StaticArrays.SVector{S}}) where {T,S} =
+    nestedview(A, StaticArrays.SVector{S,T})

src/statsbase_support.jl

@@ -0,0 +1,16 @@
+# This file is a part of ArraysOfArrays.jl, licensed under the MIT License (MIT).
+
+
+Base.sum(X::AbstractVectorOfSimilarArrays{T,M}, w::StatsBase.AbstractWeights) where {T,M} = sum(flatview(X), w, M + 1)
+
+Statistics.mean(X::AbstractVectorOfSimilarArrays{T,M}, w::StatsBase.AbstractWeights) where {T,M} =
+    mean(flatview(X), w, M + 1)
+
+Statistics.var(X::AbstractVectorOfSimilarArrays{T,M}, w::StatsBase.AbstractWeights; corrected::Bool = true) where {T,M} =
+    var(flatview(X), w, M + 1; corrected = corrected)
+
+Statistics.cov(X::AbstractVectorOfSimilarVectors, w::StatsBase.AbstractWeights; corrected::Bool = true) =
+    cov(flatview(X), w, 2; corrected = corrected)
+
+Statistics.cor(X::AbstractVectorOfSimilarVectors, w::StatsBase.AbstractWeights) =
+    cor(flatview(X), w, 2)

test/REQUIRE

@@ -1 +1,2 @@
 ElasticArrays
+StaticArrays

test/functions.jl

@@ -3,6 +3,8 @@
 using ArraysOfArrays
 using Test
 
+using StaticArrays
+
 
 @testset "functions" begin
     function gen_nested()
@@ -14,6 +16,15 @@ using Test
     end
 
 
+    @testset "flatview and nestedview" begin
+        A = [(@SArray randn(3, 2, 4)) for i in 1:2, j in 1:2]
+        @test @inferred(nestedview(flatview(A), Val(3))) == A
+
+        B = rand(3, 2, 4)
+        @test @inferred(nestedview(flatview(B), SVector{3})) == @inferred(nestedview(B, Val(1)))
+    end
+
+
     @testset "deepgetindex" begin
         A = gen_nested()
         @test @inferred(deepgetindex(A, 1, 2)) === A[1, 2]