rename

Author: Pietro Vertechi

Diff for: .travis.yml

@@ -27,9 +27,9 @@ git:
 
 ## uncomment the following lines to override the default test script
 #script:
-#  - julia -e 'Pkg.clone(pwd()); Pkg.build("StructureArrays"); Pkg.test("StructureArrays"; coverage=true)'
+#  - julia -e 'Pkg.clone(pwd()); Pkg.build("StructArrays"); Pkg.test("StructArrays"; coverage=true)'
 after_success:
   # push coverage results to Coveralls
-  - julia -e 'cd(Pkg.dir("StructureArrays")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'
+  - julia -e 'cd(Pkg.dir("StructArrays")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'
   # push coverage results to Codecov
-  - julia -e 'cd(Pkg.dir("StructureArrays")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'
+  - julia -e 'cd(Pkg.dir("StructArrays")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'

Diff for: LICENSE.md

@@ -1,4 +1,4 @@
-The StructureArrays.jl package is licensed under the MIT "Expat" License:
+The StructArrays.jl package is licensed under the MIT "Expat" License:
 
 > Copyright (c) 2018: Pietro Vertechi.
 >

Diff for: README.md

@@ -1,9 +1,9 @@
-# StructureArrays
+# StructArrays
 
-[![Build Status](https://travis-ci.org/piever/StructureArrays.jl.svg?branch=master)](https://travis-ci.org/piever/StructureArrays.jl)
-[![codecov.io](http://codecov.io/github/piever/StructureArrays.jl/coverage.svg?branch=master)](http://codecov.io/github/piever/StructureArrays.jl?branch=master)
+[![Build Status](https://travis-ci.org/piever/StructArrays.jl.svg?branch=master)](https://travis-ci.org/piever/StructArrays.jl)
+[![codecov.io](http://codecov.io/github/piever/StructArrays.jl/coverage.svg?branch=master)](http://codecov.io/github/piever/StructArrays.jl?branch=master)
 
-This package introduces the type `StructureArray` which is an `AbstractArray` whose elements are `struct` (for example `NamedTuples`,  or `ComplexF64`, or a custom user defined `struct`). While a `StructureArray` iterates `structs`, the layout is column based (meaning each field of the `struct` is stored in a seprate `Array`).
+This package introduces the type `StructArray` which is an `AbstractArray` whose elements are `struct` (for example `NamedTuples`,  or `ComplexF64`, or a custom user defined `struct`). While a `StructArray` iterates `structs`, the layout is column based (meaning each field of the `struct` is stored in a seprate `Array`).
 
 `Base.getproperty` or the dot syntax can be used to access columns, whereas rows can be accessed with `getindex`.
 
@@ -12,12 +12,12 @@ The package is largely inspired from the `Columns` type in [IndexedTables](https
 ## Example usage to store complex numbers
 
 ```julia
-julia> using StructureArrays, Random
+julia> using StructArrays, Random
 
 julia> srand(4);
 
-julia> s = StructureArray{ComplexF64}(rand(2,2), rand(2,2))
-2×2 StructureArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}}}:
+julia> s = StructArray{ComplexF64}(rand(2,2), rand(2,2))
+2×2 StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}}}:
  0.680079+0.625239im   0.92407+0.267358im
  0.874437+0.737254im  0.929336+0.804478im
 
@@ -33,8 +33,8 @@ julia> s.re
 ## Example usage to store a data table
 
 ```julia
-julia> t = StructureArray((a = [1, 2], b = ["x", "y"]))
-2-element StructureArray{NamedTuple{(:a, :b),Tuple{Int64,String}},1,NamedTuple{(:a, :b),Tuple{Array{Int64,1},Array{String,1}}}}:
+julia> t = StructArray((a = [1, 2], b = ["x", "y"]))
+2-element StructArray{NamedTuple{(:a, :b),Tuple{Int64,String}},1,NamedTuple{(:a, :b),Tuple{Array{Int64,1},Array{String,1}}}}:
  (a = 1, b = "x")
  (a = 2, b = "y")
 
@@ -47,7 +47,7 @@ julia> t.a
  2
 
 julia> push!(t, (a = 3, b = "z"))
-3-element StructureArray{NamedTuple{(:a, :b),Tuple{Int64,String}},1,NamedTuple{(:a, :b),Tuple{Array{Int64,1},Array{String,1}}}}:
+3-element StructArray{NamedTuple{(:a, :b),Tuple{Int64,String}},1,NamedTuple{(:a, :b),Tuple{Array{Int64,1},Array{String,1}}}}:
  (a = 1, b = "x")
  (a = 2, b = "y")
  (a = 3, b = "z")

Diff for: appveyor.yml

@@ -41,7 +41,7 @@ build_script:
 # Need to convert from shallow to complete for Pkg.clone to work
   - IF EXIST .git\shallow (git fetch --unshallow)
   - C:\projects\julia\bin\julia -e "versioninfo();
-      Pkg.clone(pwd(), \"StructureArrays\"); Pkg.build(\"StructureArrays\")"
+      Pkg.clone(pwd(), \"StructArrays\"); Pkg.build(\"StructArrays\")"
 
 test_script:
-  - C:\projects\julia\bin\julia -e "Pkg.test(\"StructureArrays\")"
+  - C:\projects\julia\bin\julia -e "Pkg.test(\"StructArrays\")"

Diff for: src/StructureArrays.jl renamed to src/StructArrays.jl

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

Diff for: src/structarray.jl

@@ -0,0 +1,84 @@
+"""
+A type that stores an array of structures as a structure of arrays.
+# Fields:
+- `columns`: a tuple of arrays. Also `columns(x)`
+"""
+struct StructArray{T, N, C<:Tup} <: AbstractArray{T, N}
+    columns::C
+
+    function StructArray{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
+
+StructArray{T}(c::C) where {T, C<:Tuple} = StructArray{T}(NamedTuple{fields(T)}(c))
+StructArray{T}(c::C) where {T, C<:NamedTuple} =
+    StructArray{createtype(T, eltypes(C)), length(size(c[1])), C}(c)
+StructArray(c::C) where {C<:NamedTuple} = StructArray{C}(c)
+
+StructArray{T}(args...) where {T} = StructArray{T}(NamedTuple{fields(T)}(args))
+
+columns(s::StructArray) = getfield(s, :columns)
+getproperty(s::StructArray, key::Symbol) = getfield(columns(s), key)
+getproperty(s::StructArray, key::Int) = getfield(columns(s), key)
+
+size(s::StructArray) = size(columns(s)[1])
+
+getindex(s::StructArray, I::Int...) = get_ith(s, I...)
+function getindex(s::StructArray{T, N, C}, I::Union{Int, AbstractArray, Colon}...) where {T, N, C}
+    StructArray{T}(map(v -> getindex(v, I...), columns(s)))
+end
+
+function view(s::StructArray{T, N, C}, I...) where {T, N, C}
+    StructArray{T}(map(v -> view(v, I...), columns(s)))
+end
+
+setindex!(s::StructArray, val, I::Int...) = set_ith!(s, val, I...)
+
+fields(T) = fieldnames(T)
+fields(::Type{<:NamedTuple{K}}) where {K} = K
+fields(::Type{<:StructArray{T}}) where {T} = fields(T)
+
+@generated function push!(s::StructArray{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::StructArray{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::StructArray...)
+    f = key -> cat(dims, (getproperty(t, key) for t in args)...)
+    T = mapreduce(eltype, promote_type, args)
+    StructArray{T}(map(f, fields(eltype(args[1]))))
+end
+
+for op in [:hcat, :vcat]
+    @eval begin
+        function $op(args::StructArray...)
+            f = key -> $op((getproperty(t, key) for t in args)...)
+            T = mapreduce(eltype, promote_type, args)
+            StructArray{T}(map(f, fields(eltype(args[1]))))
+        end
+    end
+end

Diff for: src/structurearray.jl

@@ -5,7 +5,7 @@ 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)
 
-@generated function get_ith(s::StructureArray{T}, I...) where {T}
+@generated function get_ith(s::StructArray{T}, I...) where {T}
     args = []
     for key in fields(T)
         field = Expr(:., :s, Expr(:quote, key))
@@ -14,7 +14,7 @@ eltypes(::Type{NamedTuple{K, V}}) where {K, V} = eltypes(V)
     Expr(:call, :createinstance, :T, args...)
 end
 
-@generated function set_ith!(s::StructureArray{T}, vals, I...) where {T}
+@generated function set_ith!(s::StructArray{T}, vals, I...) where {T}
     args = []
     for key in fields(T)
         field = Expr(:., :s, Expr(:quote, key))

Diff for: src/utils.jl

@@ -1,33 +1,33 @@
-using StructureArrays
+using StructArrays
 using Test
 
 # write your own tests here
 @testset "index" begin
     a, b = [1 2; 3 4], [4 5; 6 7]
-    t = StructureArray((a = a, b = b))
+    t = StructArray((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)))
+    @test t[2,1:2] == StructArray((a = [3, 4], b = [6, 7]))
+    @test view(t, 2, 1:2) == StructArray((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)
+    t = StructArray{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))
+    @test t[2,1:2] == StructArray{ComplexF64}([3, 4], [6, 7])
+    @test view(t, 2, 1:2) == StructArray{ComplexF64}(view(a, 2, 1:2), view(b, 2, 1:2))
 end
 
 @testset "concat" begin
-    t = StructureArray{Pair}([3, 5], ["a", "b"])
+    t = StructArray{Pair}([3, 5], ["a", "b"])
     push!(t, (2 => "c"))
-    @test t == StructureArray{Pair}([3, 5, 2], ["a", "b", "c"])
+    @test t == StructArray{Pair}([3, 5, 2], ["a", "b", "c"])
     append!(t, t)
-    @test t == StructureArray{Pair}([3, 5, 2, 3, 5, 2], ["a", "b", "c", "a", "b", "c"])
-    t = StructureArray{Pair}([3, 5], ["a", "b"])
-    t2 = StructureArray{Pair}([1, 6], ["a", "b"])
-    @test cat(1, t, t2) == StructureArray{Pair}([3, 5, 1, 6], ["a", "b", "a", "b"]) == vcat(t, t2)
-    @test vcat(t, t2) isa StructureArray
-    @test cat(2, t, t2) == StructureArray{Pair}([3 1; 5 6], ["a" "a"; "b" "b"]) == hcat(t, t2)
-    @test hcat(t, t2) isa StructureArray
+    @test t == StructArray{Pair}([3, 5, 2, 3, 5, 2], ["a", "b", "c", "a", "b", "c"])
+    t = StructArray{Pair}([3, 5], ["a", "b"])
+    t2 = StructArray{Pair}([1, 6], ["a", "b"])
+    @test cat(1, t, t2) == StructArray{Pair}([3, 5, 1, 6], ["a", "b", "a", "b"]) == vcat(t, t2)
+    @test vcat(t, t2) isa StructArray
+    @test cat(2, t, t2) == StructArray{Pair}([3 1; 5 6], ["a" "a"; "b" "b"]) == hcat(t, t2)
+    @test hcat(t, t2) isa StructArray
 end