repalce names -> dimnames

Author: Michael Abbott

Project.toml

@@ -14,7 +14,7 @@ Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 
 [compat]
 IntervalSets = "0.3, 0.4"
-NamedDims = "0.2.14"
+NamedDims = "0.2.18"
 LazyStack = "0.0.7"
 OffsetArrays = "0.10, 0.11"
 Tables = "0.2, 1"

README.md

@@ -98,7 +98,7 @@ ranges(ans,1) # 10:10:100 with indices 0:9
 ### Functions
 
 As usual `axes(A)` returns (a tuple of vectors of) indices, and `ranges(A)` returns keys.
-If the array has names, then `names(A)` returns them, and functions like `axes(A, name)` 
+If the array has names, then `dimnames(A)` returns them, and functions like `axes(A, name)` 
 give just one.
 
 Many functions should work, for example:

src/AxisRanges.jl

@@ -4,7 +4,7 @@ include("struct.jl")
 export RangeArray, ranges
 
 include("names.jl")
-export NamedDimsArray, namedranges, namedaxes
+export NamedDimsArray, dimnames
 
 include("wrap.jl")
 export wrapdims

src/functions.jl

@@ -35,7 +35,7 @@ tuple_flatten() = ()
 
 function Base.mapreduce(f, op, A::RangeArray; dims=:) # sum, prod, etc
     dims === Colon() && return mapreduce(f, op, parent(A))
-    numerical_dims = hasnames(A) ? NamedDims.dim(names(A), dims) : dims
+    numerical_dims = hasnames(A) ? NamedDims.dim(dimnames(A), dims) : dims
     data = mapreduce(f, op, parent(A); dims=numerical_dims)
     new_ranges = ntuple(d -> d in numerical_dims ? Base.OneTo(1) : ranges(A,d), ndims(A))
     return RangeArray(data, map(copy, new_ranges))#, copy(A.meta))
@@ -45,23 +45,23 @@ using Statistics
 for fun in [:mean, :std, :var] # These don't use mapreduce, but could perhaps be handled better?
     @eval function Statistics.$fun(A::RangeArray; dims=:)
         dims === Colon() && return $fun(parent(A))
-        numerical_dims = hasnames(A) ? NamedDims.dim(names(A), dims) : dims
+        numerical_dims = hasnames(A) ? NamedDims.dim(dimnames(A), dims) : dims
         data = $fun(parent(A); dims=numerical_dims)
         new_ranges = ntuple(d -> d in numerical_dims ? Base.OneTo(1) : ranges(A,d), ndims(A))
         return RangeArray(data, map(copy, new_ranges))#, copy(A.meta))
     end
     VERSION >= v"1.3" &&
     @eval function Statistics.$fun(f, A::RangeArray; dims=:)
         dims === Colon() && return $fun(f, parent(A))
-        numerical_dims = hasnames(A) ? NamedDims.dim(names(A), dims) : dims
+        numerical_dims = hasnames(A) ? NamedDims.dim(dimnames(A), dims) : dims
         data = $fun(f, parent(A); dims=numerical_dims)
         new_ranges = ntuple(d -> d in numerical_dims ? Base.OneTo(1) : ranges(A,d), ndims(A))
         return RangeArray(data, map(copy, new_ranges))#, copy(A.meta))
     end
 end
 
 function Base.dropdims(A::RangeArray; dims)
-    numerical_dims = hasnames(A) ? NamedDims.dim(names(A), dims) : dims
+    numerical_dims = hasnames(A) ? NamedDims.dim(dimnames(A), dims) : dims
     data = dropdims(A.data; dims=dims)
     ranges = range_skip(A.ranges, numerical_dims...)
     RangeArray(data, ranges)#, A.meta)
@@ -73,7 +73,7 @@ range_skip(tup::Tuple, d, dims...) = range_skip(
 range_skip(tup::Tuple) = tup
 
 function Base.permutedims(A::RangeArray, perm)
-    numerical_perm = hasnames(A) ? NamedDims.dim(names(A), perm) : perm
+    numerical_perm = hasnames(A) ? NamedDims.dim(dimnames(A), perm) : perm
     data = permutedims(A.data, numerical_perm)
     new_ranges = ntuple(d -> copy(ranges(A, perm[d])), ndims(A))
     RangeArray(data, new_ranges)#, copy(A.meta))
@@ -128,7 +128,7 @@ range_vcat(a::Base.OneTo, b::Base.OneTo) = Base.OneTo(a.stop + b.stop)
 range_vcat(a,b,cs...) = range_vcat(range_vcat(a,b),cs...)
 
 function Base.sort(A::RangeArray; dims, kw...)
-    dims′ = hasnames(A) ? NamedDims.dim(names(A), dims) : dims
+    dims′ = hasnames(A) ? NamedDims.dim(dimnames(A), dims) : dims
     data = sort(parent(A); dims=dims′, kw...)
     # sorts each (say) col independently, thus range along them loses meaning.
     new_ranges = ntuple(d -> d==dims′ ? OneTo(size(A,d)) : ranges(A,d), ndims(A))
@@ -140,7 +140,7 @@ function Base.sort(A::RangeVector; kw...)
 end
 
 function Base.sortslices(A::RangeArray; dims, kw...)
-    dims′ = hasnames(A) ? NamedDims.dim(names(A), dims) : dims
+    dims′ = hasnames(A) ? NamedDims.dim(dimnames(A), dims) : dims
     data = sortslices(parent(A); dims=dims′, kw...)
     # It would be nice to sort the range to match, but there is no sortpermslices.
     # https://github.com/davidavdav/NamedArrays.jl/issues/79 constructs something
@@ -169,11 +169,11 @@ for fun in [:copy, :deepcopy, :similar, :zero, :one]
     @eval Base.$fun(A::RangeArray) = RangeArray($fun(parent(A)), map(copy, ranges(A)))
     @eval Base.$fun(A::NdaRa) = NamedDimsArray(RangeArray(
         $fun(parent(parent(A))),
-        map(copy, ranges(A))), names(A))
+        map(copy, ranges(A))), dimnames(A))
 end
 Base.similar(A::RangeArray, T::Type) = RangeArray(similar(A.data, T), map(copy, A.ranges))
 Base.similar(A::NdaRa, T::Type) = NamedDimsArray(RangeArray(
-    similar(A.data.data, T), map(copy, ranges(A))), names(A))
+    similar(A.data.data, T), map(copy, ranges(A))), dimnames(A))
 Base.similar(A::RangeArray, T::Type, dims::Int...) = similar(A.data, T, dims...)
 Base.similar(A::RangeArray, dims::Int...) = similar(A.data, dims...)
 

src/names.jl

@@ -10,10 +10,8 @@ NdaRaVoM{L,T,N} = NamedDimsArray{L,T,N,<:RangeVecOrMat}
 
 # Just make names get the names, and behave like size(A,d), axes(A,d) etc.
 
-Base.names(A::RaNda{L}) where {L} = L
-Base.names(A::RaNda{L,T,N}, d::Int) where {L,T,N} = d <= N ? L[d] : :_
-Base.names(A::NamedDimsArray{L}) where {L} = L # 🏴‍☠️
-Base.names(A::NamedDimsArray{L,T,N}, d::Int) where {L,T,N} = d <= N ? L[d] : :_ # 🏴‍☠️
+NamedDims.dimnames(A::RaNda{L}) where {L} = L
+NamedDims.dimnames(A::RaNda{L,T,N}, d::Int) where {L,T,N} = d <= N ? L[d] : :_
 
 Base.axes(A::RaNda{L}, s::Symbol) where {L} = axes(A, NamedDims.dim(L,s))
 Base.size(A::RaNda{L,T,N}, s::Symbol) where {T,N,L} = size(A, NamedDims.dim(L,s))
@@ -71,12 +69,12 @@ Base.getproperty(A::NamedDimsArray{L}, s::Symbol) where {L} =
 
 @inline @propagate_inbounds function Base.getindex(A::RangeArray; kw...)
     hasnames(A) || error("must have names!")
-    inds = NamedDims.order_named_inds(Val(names(A)); kw...)
+    inds = NamedDims.order_named_inds(Val(dimnames(A)); kw...)
     getindex(A, inds...)
 end
 @inline @propagate_inbounds function Base.view(A::RangeArray; kw...)
     hasnames(A) || error("must have names!")
-    inds = NamedDims.order_named_inds(Val(names(A)); kw...)
+    inds = NamedDims.order_named_inds(Val(dimnames(A)); kw...)
     view(A, inds...)
 end
 
@@ -88,7 +86,7 @@ end
 @inline @propagate_inbounds (A::NdaRa)(;kw...) = getkey(A; kw...)
 
 @inline @propagate_inbounds function getkey(A; kw...)
-    list = names(A)
+    list = dimnames(A)
     issubset(kw.itr, list) || error("some keywords not in list of names!")
     args = map(s -> Base.sym_in(s, kw.itr) ? getfield(kw.data, s) : Colon(), list)
     A(args...)
@@ -101,7 +99,7 @@ end
     namedranges(A)
     namedaxes(A)
 
-Combines `names(A)` and either `ranges(A)` or `axes(A)` into a `NamedTuple`.
+Combines `dimnames(A)` and either `ranges(A)` or `axes(A)` into a `NamedTuple`.
 """
 namedranges(A::NdaRa{L}) where {L} = NamedTuple{L}(ranges(A))
 namedranges(A::RaNda{L}) where {L} = NamedTuple{L}(ranges(A))

src/show.jl

@@ -9,7 +9,7 @@ function _summary(io, x)
     for d in 1:ndims(x)
         print(io, d==1 ? "↓" : d==2 ? "→" : "□", "   ")
         c = colour(x, d)
-        hasnames(x) && printstyled(io, names(x,d), " ∈ ", color=c)
+        hasnames(x) && printstyled(io, dimnames(x,d), " ∈ ", color=c)
         printstyled(io, length(ranges(x,d)), "-element ", shorttype(ranges(x,d)), "\n", color=c)
     end
     print(io, "And data, ", summary(rangeless(unname(x))))
@@ -173,7 +173,7 @@ function limited_show_nd(io::IO, a::AbstractArray, print_matrix::Function, label
             printstyled(io, "[:, :", color=c3)
             for i = 1:nd
                 if hasnames(a) && !hasranges(a)
-                    name = names(a, i+2)
+                    name = dimnames(a, i+2)
                     printstyled(io, ", $name=$(idxs[i])", color=c3)
                 else
                     printstyled(io, ", $(idxs[i])", color=c3)
@@ -186,7 +186,7 @@ function limited_show_nd(io::IO, a::AbstractArray, print_matrix::Function, label
                 for i = 1:nd
                     key = sprint(show, ranges(a, i+2)[idxs[i]], context=io)
                     # if hasnames(a)
-                    #     name = names(a, i+2)
+                    #     name = dimnames(a, i+2)
                     #     printstyled(io, ", $name = $key", color=c3)
                     # else
                         printstyled(io, ", $key", color=c3)
@@ -208,13 +208,13 @@ end
 function Base.summary(io::IO, A::NamedDimsArray)
     print(io, Base.dims2string(size(A)), " NamedDimsArray(")
     Base.showarg(io, parent(A), false)
-    print(io, ", ", names(A), ")")
+    print(io, ", ", dimnames(A), ")")
 end
 
 function Base.print_matrix(io::IO, A::NamedDimsArray)
-    s1 = string("↓ ", names(A,1)) * "  "
+    s1 = string("↓ ", dimnames(A,1)) * "  "
     if ndims(A)==2
-        s2 = string(" "^length(s1), "→ ", names(A,2), "\n")
+        s2 = string(" "^length(s1), "→ ", dimnames(A,2), "\n")
         printstyled(io, s2, color=:magenta)
     end
     ioc = IOContext(io, :displaysize => displaysize(io) .- (2, 0))
@@ -225,12 +225,12 @@ end
 # A hack to avoid big messy function?
 
 function Base.print_array(io::IO, A::NamedDimsArray{L,T,3}) where {L,T}
-    s3 = string("[", names(A,3), " ⤋ ]")
+    s3 = string("[", dimnames(A,3), " ⤋ ]")
     printstyled(io, s3, color=:magenta)
     Base.show_nd(io, A, Base.print_matrix, true)
 end
 function Base.print_array(io::IO, A::NamedDimsArray{L,T,4}) where {L,T}
-    s3 = string("[", names(A,3),", ", names(A,4), " ⤋ ]")
+    s3 = string("[", dimnames(A,3),", ", dimnames(A,4), " ⤋ ]")
     printstyled(io, s3, color=:magenta)
     Base.show_nd(io, A, Base.print_matrix, true)
 end

src/stack.jl

@@ -54,6 +54,6 @@ function LazyStack.getnames(xs::RangeArray{<:AbstractArray,N,OT}) where {N,OT}
     (dimnames(eltype(xs))..., dimnames(OT)...)
 end
 function LazyStack.getnames(xs::AbstractArray{<:RangeArray{T,N,IT}}) where {T,N,IT}
-    out_names = hasnames(xs) ? names(xs) : NamedDims.dimnames(xs)
+    out_names = hasnames(xs) ? dimnames(xs) : NamedDims.dimnames(xs)
     (NamedDims.dimnames(IT)..., out_names...)
 end

src/tables.jl

@@ -10,7 +10,7 @@ Tables.istable(::Type{<:RangeArray}) = true
 Tables.rowaccess(::Type{<:RangeArray}) = true
 
 function Tables.rows(A::Union{RangeArray, NdaRa})
-    L = hasnames(A) ? (names(A)..., :value) :  # should gensym() if :value in names(A)
+    L = hasnames(A) ? (dimnames(A)..., :value) :  # should gensym() if :value in dimnames(A)
         (ntuple(d -> Symbol(:dim_,d), ndims(A))..., :value)
     R = ranges_or_axes(A)
     nt(inds) = NamedTuple{L}((map(getindex, R, inds)..., A[inds...]))
@@ -35,7 +35,7 @@ Tables.columnaccess(::Type{<:RangeArray{T,N,AT}}) where {T,N,AT} =
     IndexStyle(AT) === IndexLinear()
 
 function Tables.columns(A::Union{RangeArray, NdaRa})
-    L = hasnames(A) ? (names(A)..., :value) :
+    L = hasnames(A) ? (dimnames(A)..., :value) :
         (ntuple(d -> Symbol(:dim_,d), ndims(A))..., :value)
     R = ranges_or_axes(A)
     G = ntuple(ndims(A)) do d

test/_basic.jl

@@ -82,8 +82,8 @@ end
 @testset "names" begin
 
     # constructor
-    @test names(wrapdims(rand(3), :a)) == (:a,)
-    @test names(wrapdims(rand(3), b=1:3), 1) == :b
+    @test dimnames(wrapdims(rand(3), :a)) == (:a,)
+    @test dimnames(wrapdims(rand(3), b=1:3), 1) == :b
     @test ranges(wrapdims(rand(3), b=1:3)) == (1:3,)
     @test ranges(wrapdims(rand(3), b=1:3), :b) == 1:3
 
@@ -99,13 +99,13 @@ end
     # indexing etc, of commutative wrappers
     data = rand(1:99, 3,4)
     N1 = wrapdims(data, obs = ['a', 'b', 'c'], iter = 10:10:40)
-    N2 = NamedDimsArray(RangeArray(data, ranges(N1)), names(N1))
-    N3 = RangeArray(NamedDimsArray(data, names(N1)), ranges(N1))
+    N2 = NamedDimsArray(RangeArray(data, ranges(N1)), dimnames(N1))
+    N3 = RangeArray(NamedDimsArray(data, dimnames(N1)), ranges(N1))
 
     @testset "with $(typeof(N).name) outside" for N in [N2, N3]
         @test ranges(N) == (['a', 'b', 'c'], 10:10:40)
         @test ranges(N, :iter) == 10:10:40
-        @test names(N) == (:obs, :iter)
+        @test dimnames(N) == (:obs, :iter)
         @test axes(N, :obs) == 1:3
         @test size(N, :obs) == 3
 
@@ -116,7 +116,7 @@ end
         @test N(obs='a') == N('a') == N[1,:] == N[obs=1]
         @test N(obs='a') == N('a') == view(N, 1,:) == view(N, obs=1)
 
-        @test names(N(obs='a')) == (:iter,)
+        @test dimnames(N(obs='a')) == (:iter,)
         @test ranges(N(obs='b')) == (10:10:40,)
 
         @test_throws Exception N(obs=55)  # ideally ArgumentError
@@ -150,10 +150,10 @@ end
         mat_y = wrapdims(ones(2,2), :_, :y)
 
         @test ranges(vec_x .+ mat_r .+ mat_y) == ranges(mat_r)
-        @test names(vec_x .+ mat_r .+ mat_y) == (:x, :y)
+        @test dimnames(vec_x .+ mat_r .+ mat_y) == (:x, :y)
 
         @test ranges(sqrt.(vec_x .+ vec_y') ./ mat_r) == ranges(mat_r)
-        @test names(sqrt.(vec_x .+ vec_y') ./ mat_r) == (:x, :y)
+        @test dimnames(sqrt.(vec_x .+ vec_y') ./ mat_r) == (:x, :y)
 
         yy = vec_y .+ mat_y
         @test ranges(yy' .+ mat_r) == (11:12, 'α':'β')
@@ -168,10 +168,10 @@ end
         v3 = wrapdims(ones(2), [11, 22])
         z = zeros(2,2)
 
-        @test names(v1 .= v1 .+ v2) == (:μ,)
+        @test dimnames(v1 .= v1 .+ v2) == (:μ,)
         @test v1[1] == 2
 
-        @test names(v2 .= v3 .+ 5) == (:μ,)
+        @test dimnames(v2 .= v3 .+ 5) == (:μ,)
         @test v2[1] == 6
 
         @test ranges(z .= v1 .+ v2') == (["a", "b"], Base.OneTo(2))

test/_functions.jl

@@ -23,13 +23,13 @@ V = wrapdims(rand(1:99, 10), v=10:10:100)
     @test ranges(dropdims(M2, dims=:c)) == ('a':'c',)
 
     M3 = dropdims(M2, dims=:c)
-    @test names(M3) == (:r,)
+    @test dimnames(M3) == (:r,)
 
     # permutedims
     @test size(permutedims(M)) == (4,3)
-    @test names(transpose(M2)) == (:c, :r)
+    @test dimnames(transpose(M2)) == (:c, :r)
     @test ranges(permutedims(M, (2,1))) == (2:5, 'a':'c')
-    @test names(M3') == (:_, :r)
+    @test dimnames(M3') == (:_, :r)
     @test ranges(transpose(transpose(V))) == ranges(V)
     @test ranges(permutedims(transpose(V))) == (ranges(V,1), Base.OneTo(1))
 
@@ -58,7 +58,7 @@ end
 
     mapM =  map(exp, M)
     @test ranges(mapM) == ('a':'c', 2:5) # fails with nda(ra(...)), has lost ranges?
-    @test names(mapM) == (:r, :c)
+    @test dimnames(mapM) == (:r, :c)
 
     @test ranges(map(+, M, M, M)) == ('a':'c', 2:5)
     @test ranges(map(+, M, parent(M))) == ('a':'c', 2:5)
@@ -72,20 +72,20 @@ end
 
     genM =  [exp(x) for x in M]
     @test ranges(genM) == ('a':'c', 2:5) # fails with nda(ra(...))
-    @test names(genM) == (:r, :c)
+    @test dimnames(genM) == (:r, :c)
 
     @test ranges([exp(x) for x in V]) == (10:10:100,)
 
     gen3 = [x+y for x in M, y in V];
     @test ranges(gen3) == ('a':'c', 2:5, 10:10:100)
-    @test names(gen3) == (:r, :c, :v)
+    @test dimnames(gen3) == (:r, :c, :v)
 
     gen1 = [x^i for (i,x) in enumerate(V)]
     @test ranges(gen1) == (10:10:100,)
-    @test names(gen1) == (:v,)
+    @test dimnames(gen1) == (:v,)
 
     @test ranges(filter(isodd, V2),1) isa Vector{Int}
-    @test names(filter(isodd, V2)) == (:v,)
+    @test dimnames(filter(isodd, V2)) == (:v,)
 
     @test filter(isodd, M) isa Array
 
@@ -132,15 +132,15 @@ end
     @test (V' * rand(Int, 10)) isa Int
     @test (rand(Int, 10)' * V) isa Int
     @test ranges(V * V') === (10:10:100, 10:10:100)
-    @test names(V * V') === (:v, :v)
+    @test dimnames(V * V') === (:v, :v)
     @test ranges(V * rand(1,10)) === (10:10:100, Base.OneTo(10))
-    @test names(V * rand(1,10)) === (:v, :_)
+    @test dimnames(V * rand(1,10)) === (:v, :_)
 
     # matrix * vector
     @test ranges(M * M('a')) === ('a':'c',)
-    @test names(M * M('a')) === (:r,)
+    @test dimnames(M * M('a')) === (:r,)
     @test ranges(M(5)' * M) === (Base.OneTo(1), 2:5)
-    @test names(M(5)' * M) === (:_, :c)
+    @test dimnames(M(5)' * M) === (:_, :c)
 
 end
 @testset "div" begin # doesn't work for names yet
@@ -166,8 +166,8 @@ end
     @test ranges(similar(MN, Int)) == ranges(M)
     @test AxisRanges.hasranges(similar(M, Int, 3,3)) == false
     @test AxisRanges.hasranges(similar(MN, Int, 3,3)) == false
-    @test names(similar(M, 3,3)) == (:r, :c)
-    @test names(similar(MN, 3,3)) == (:r, :c)
+    @test dimnames(similar(M, 3,3)) == (:r, :c)
+    @test dimnames(similar(MN, 3,3)) == (:r, :c)
     @test AxisRanges.hasnames(similar(M, 2,2,2)) == false
     @test AxisRanges.hasnames(similar(MN, 2,2,2)) == false