tests

Author: Pietro Vertechi

.travis.yml

@@ -2,9 +2,9 @@
 language: julia
 os:
   - linux
-  - osx
+  #- osx
 julia:
-  - 0.6
+  #- 0.6
   - nightly
 notifications:
   email: false

src/StructureArrays.jl

@@ -1,7 +1,7 @@
 module StructureArrays
 
 import Base:
-    getindex, setindex!, size, push!, view, getproperty
+    getindex, setindex!, size, push!, view, getproperty, append!, cat
 #     linearindexing, push!, size, sort, sort!, permute!, issorted, sortperm,
 #     summary, resize!, vcat, serialize, deserialize, append!, copy!, view
 

src/structurearray.jl

@@ -17,18 +17,59 @@ struct StructureArray{T, N, C<:Tup} <: AbstractArray{T, N}
     end
 end
 
+StructureArray{T}(c::C) where {T, C<:Tuple} = StructureArray{T}(NamedTuple{fields(T)}(c))
 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...)
+getindex(s::StructureArray, I::Int...) = get_ith(s, I...)
+function getindex(s::StructureArray{T, N, C}, I::Union{Int, AbstractArray, Colon}...) where {T, N, C}
+    StructureArray{T}(map(v -> getindex(v, I...), columns(s)))
+end
+
+function view(s::StructureArray{T, N, C}, I...) where {T, N, C}
+    StructureArray{T}(map(v -> view(v, I...), columns(s)))
+end
+
+setindex!(s::StructureArray, val, I::Int...) = set_ith!(s, val, I...)
+
+fields(T) = fieldnames(T)
+fields(::Type{<:NamedTuple{K}}) where {K} = K
+fields(::Type{<:StructureArray{T}}) where {T} = fields(T)
+
+@generated function push!(s::StructureArray{T, 1}, vals) where {T}
+    args = []
+    for key in fields(T)
+        field = Expr(:., :s, Expr(:quote, key))
+        val = Expr(:., :vals, Expr(:quote, key))
+        push!(args, :(push!($field, $val)))
+    end
+    push!(args, :s)
+    Expr(:block, args...)
+end
+
+@generated function append!(s::StructureArray{T, 1}, vals) where {T}
+    args = []
+    for key in fields(T)
+        field = Expr(:., :s, Expr(:quote, key))
+        val = Expr(:., :vals, Expr(:quote, key))
+        push!(args, :(append!($field, $val)))
+    end
+    push!(args, :s)
+    Expr(:block, args...)
+end
+
+function cat(dims, args::StructureArray...)
+    f = key -> cat(dims, (getproperty(t, key) for t in args)...)
+    T = mapreduce(eltype, promote_type, args)
+    #map(f, fields(eltype(args[1])))
+    StructureArray{T}(map(f, fields(eltype(args[1]))))
+end

src/utils.jl

@@ -4,12 +4,8 @@ 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}
+@generated function get_ith(s::StructureArray{T}, I...) where {T}
     args = []
     for key in fields(T)
         field = Expr(:., :s, Expr(:quote, key))
@@ -18,6 +14,17 @@ fields(::Type{<:NamedTuple{K}}) where {K} = K
     Expr(:call, :createinstance, :T, args...)
 end
 
+@generated function set_ith!(s::StructureArray{T}, vals, I...) where {T}
+    args = []
+    for key in fields(T)
+        field = Expr(:., :s, Expr(:quote, key))
+        val = Expr(:., :vals, Expr(:quote, key))
+        push!(args, :($field[I...] = $val))
+    end
+    push!(args, :s)
+    Expr(:block, args...)
+end
+
 createinstance(::Type{T}, args...) where {T} = T(args...)
 createinstance(::Type{T}, args...) where {T<:Tup} = T(args)
 

test/runtests.jl

@@ -2,17 +2,18 @@ using StructureArrays
 using Test
 
 # write your own tests here
-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]))
+@testset "index" begin
+    a, b = [1 2; 3 4], [4 5; 6 7]
+    t = StructureArray((a = a, b = b))
+    @test t[2,2] == (a = 4, b = 7)
+    @test t[2,1:2] == StructureArray((a = [3, 4], b = [6, 7]))
+    @test view(t, 2, 1:2) == StructureArray((a = view(a, 2, 1:2), b = view(b, 2, 1:2)))
+end
+
+@testset "complex" begin
+    a, b = [1 2; 3 4], [4 5; 6 7]
+    t = StructureArray{ComplexF64}(a, b)
+    @test t[2,2] == ComplexF64(4, 7)
+    @test t[2,1:2] == StructureArray{ComplexF64}([3, 4], [6, 7])
+    @test view(t, 2, 1:2) == StructureArray{ComplexF64}(view(a, 2, 1:2), view(b, 2, 1:2))
+end