added StructureArray

Author: Pietro Vertechi

src/StructureArrays.jl

@@ -1,5 +1,15 @@
 module StructureArrays
 
-# package code goes here
+import Base:
+    getindex, setindex!, size, push!, view, getproperty
+#     linearindexing, push!, size, sort, sort!, permute!, issorted, sortperm,
+#     summary, resize!, vcat, serialize, deserialize, append!, copy!, view
+
+export StructureArray
+
+const Tup = Union{Tuple, NamedTuple}
+
+include("structurearray.jl")
+include("utils.jl")
 
 end # module

src/structurearray.jl

@@ -0,0 +1,34 @@
+"""
+A type that stores an array of structures as a structure of arrays.
+# Fields:
+- `columns`: a tuple of arrays. Also `columns(x)`
+"""
+struct StructureArray{T, N, C<:Tup} <: AbstractArray{T, N}
+    columns::C
+
+    function StructureArray{T, N, C}(c) where {T, N, C<:Tup}
+        length(c) > 0 || error("must have at least one column")
+        n = size(c[1])
+        length(n) == N || error("wrong number of dimensions")
+        for i = 2:length(c)
+            size(c[i]) == n || error("all columns must have same size")
+        end
+        new{T, N, C}(c)
+    end
+end
+
+StructureArray{T}(c::C) where {T, C<:NamedTuple} =
+    StructureArray{createtype(T, eltypes(C)), length(size(c[1])), C}(c)
+StructureArray(c::C) where {C<:NamedTuple} = StructureArray{C}(c)
+
+StructureArray{T}(args...) where {T} = StructureArray{T}(NamedTuple{fields(T)}(args))
+
+
+
+columns(s::StructureArray) = getfield(s, :columns)
+getproperty(s::StructureArray, key::Symbol) = getfield(columns(s), key)
+getproperty(s::StructureArray, key::Int) = getfield(columns(s), key)
+
+size(s::StructureArray) = size(columns(s)[1])
+
+getindex(s::StructureArray, I...) = ith_all(s, I...)

src/utils.jl

@@ -0,0 +1,25 @@
+import Base: tuple_type_cons, tuple_type_head, tuple_type_tail, tail
+
+eltypes(::Type{Tuple{}}) = Tuple{}
+eltypes(::Type{T}) where {T<:Tuple} =
+    tuple_type_cons(eltype(tuple_type_head(T)), eltypes(tuple_type_tail(T)))
+eltypes(::Type{NamedTuple{K, V}}) where {K, V} = eltypes(V)
+fields(T) = fieldnames(T)
+fields(::Type{<:NamedTuple{K}}) where {K} = K
+#@inline ith_all(i, ::Tuple{}) = ()
+#@inline ith_all(i, as) = (as[1][i], ith_all(i, tail(as))...)
+
+@generated function ith_all(s::StructureArray{T}, I...) where {T}
+    args = []
+    for key in fields(T)
+        field = Expr(:., :s, Expr(:quote, key))
+        push!(args, :($field[I...]))
+    end
+    Expr(:call, :createinstance, :T, args...)
+end
+
+createinstance(::Type{T}, args...) where {T} = T(args...)
+createinstance(::Type{T}, args...) where {T<:Tup} = T(args)
+
+createtype(::Type{T}, ::Type{C}) where {T<:NamedTuple{N}, C} where {N} = NamedTuple{N, C}
+createtype(::Type{T}, ::Type{C}) where {T, C} = T

test/runtests.jl

@@ -1,5 +1,18 @@
 using StructureArrays
-using Base.Test
+using Test
 
 # write your own tests here
-@test 1 == 2
+t = StructureArray{typeof((a=1.2, b =2.2))}(rand(2,3), rand(2,3));
+t[2,2]
+# s = t
+# T = typeof(t)
+# i = 1
+# args = []
+# for key in fieldnames(T)
+#     field = Expr(:., :n, Expr(:quote, key))
+#     push!(args, :($field[i]))
+# end
+# Expr(:createinstance, :T, args...)
+StructureArrays.createtype(NamedTuple{(:a, :b)}, Tuple{Float64, Float64})
+s = StructureArray{NamedTuple{(:a, :b)}}([1,2], rand(2));
+s = StructureArray((a = rand(2), b = [1,2]))