Switched out names for dimnames (#83)

* Switched out `names` for `dimnames`

* Added deprecation for `NamedDims.names` and patch bump

Project.toml

@@ -1,7 +1,7 @@
 name = "NamedDims"
 uuid = "356022a1-0364-5f58-8944-0da4b18d706f"
 authors = ["Invenia Technical Computing Corporation"]
-version = "0.2.11"
+version = "0.2.12"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

src/NamedDims.jl

@@ -7,7 +7,7 @@ using Pkg
 using Requires
 using Statistics
 
-export NamedDimsArray, dim, rename, unname
+export NamedDimsArray, dim, rename, unname, dimnames
 
 function __init__()
     # NOTE: NamedDims is only compatible with Tracker v0.2.2; but no nice way to enforce that.
@@ -24,4 +24,6 @@ include("functions.jl")
 include("functions_dims.jl")
 include("functions_math.jl")
 
+@deprecate names dimnames false
+
 end # module

src/broadcasting.jl

@@ -59,7 +59,7 @@ end
 function Base.copyto!(dest::AbstractArray, bc::Broadcasted{NamedDimsStyle{S}}) where S
     inner_bc = unwrap_broadcasted(bc)
     copyto!(dest, inner_bc)
-    L = unify_names(names(dest), broadcasted_names(bc))
+    L = unify_names(dimnames(dest), broadcasted_names(bc))
     return NamedDimsArray{L}(dest)
 end
 
@@ -69,5 +69,5 @@ function broadcasted_names(a, bs...)
     b_name = broadcasted_names(bs...)
     unify_names_longest(a_name, b_name)
 end
-broadcasted_names(a::AbstractArray) = names(a)
+broadcasted_names(a::AbstractArray) = dimnames(a)
 broadcasted_names(a) = tuple()

src/functions.jl

@@ -3,7 +3,7 @@
 ## Helpers:
 
 function nameddimsarray_result(original_nda, reduced_data, reduction_dims)
-    L = names(original_nda)
+    L = dimnames(original_nda)
     return NamedDimsArray{L}(reduced_data)
 end
 
@@ -43,7 +43,7 @@ for (mod, funs) in (
         # Vector case
         @eval function $mod.$fun(a::NamedDimsArray{L, T, 1}; kwargs...) where {L, T}
             data = $mod.$fun(parent(a); kwargs...)
-            return NamedDimsArray{NamedDims.names(a)}(data)
+            return NamedDimsArray{dimnames(a)}(data)
         end
     end
 end
@@ -134,15 +134,15 @@ Base.pop!(A::NamedDimsArray) = pop!(parent(A))
 Base.popfirst!(A::NamedDimsArray) = popfirst!(parent(A))
 
 function Base.append!(A::NamedDimsArray{L,T,1}, B::AbstractVector) where {L,T}
-    newL = unify_names(L, names(B))
+    newL = unify_names(L, dimnames(B))
     data = append!(parent(A), unname(B))
     return NamedDimsArray{newL}(data)
 end
 
 ################################################
 # map, collect
 
-Base.map(f, A::NamedDimsArray) = NamedDimsArray(map(f, parent(A)), names(A))
+Base.map(f, A::NamedDimsArray) = NamedDimsArray(map(f, parent(A)), dimnames(A))
 
 for (T, S) in [
     (:NamedDimsArray, :AbstractArray),
@@ -154,15 +154,15 @@ for (T, S) in [
         # Here f::F where {F} is needed to avoid ambiguities in Julia 1.0
         @eval function Base.$fun(f::F, a::$T, b::$S, cs::AbstractArray...) where {F}
             data = $fun(f, unname(a), unname(b), unname.(cs)...)
-            new_names = unify_names(names(a), names(b), names.(cs)...)
+            new_names = unify_names(dimnames(a), dimnames(b), dimnames.(cs)...)
             return NamedDimsArray(data, new_names)
         end
 
     end
 
     @eval function Base.foreach(f::F, a::$T, b::$S, cs::AbstractArray...) where {F}
         data = foreach(f, unname(a), unname(b), unname.(cs)...)
-        unify_names(names(a), names(b), names.(cs)...)
+        unify_names(dimnames(a), dimnames(b), dimnames.(cs)...)
         return nothing
     end
 end
@@ -188,6 +188,6 @@ Base.collect(x::Base.Generator{<:Iterators.ProductIterator{<:Tuple{<:NamedDimsAr
 
 function collect_product(x)
     data = collect(Base.Generator(x.f, Iterators.product(unname.(x.iter.iterators)...)))
-    all_names = tuple_cat(names.(x.iter.iterators)...)
+    all_names = tuple_cat(dimnames.(x.iter.iterators)...)
     return NamedDimsArray(data, all_names)
 end

src/functions_dims.jl

@@ -13,7 +13,7 @@ rename(nda::NamedDimsArray, names) = NamedDimsArray(parent(nda), names)
 function Base.dropdims(nda::NamedDimsArray; dims)
     numerical_dims = dim(nda, dims)
     data = dropdims(parent(nda); dims=numerical_dims)
-    L = remaining_dimnames_after_dropping(names(nda), numerical_dims)
+    L = remaining_dimnames_after_dropping(dimnames(nda), numerical_dims)
     return NamedDimsArray{L}(data)
 end
 

src/functions_math.jl

@@ -68,10 +68,10 @@ macro declare_matmul(MatrixT, VectorT=nothing)
 
         quote
             function Base.:*(a::$TA_named, b::$TB_other)
-                return *(a, NamedDims.NamedDimsArray{NamedDims.names(b)}(b))
+                return *(a, NamedDims.NamedDimsArray{dimnames(b)}(b))
             end
             function Base.:*(a::$TA_other, b::$TB_named)
-                return *(NamedDims.NamedDimsArray{NamedDims.names(a)}(a), b)
+                return *(NamedDims.NamedDimsArray{dimnames(a)}(a), b)
             end
         end
     end

src/wrapper_array.jl

@@ -73,13 +73,13 @@ unname(x::NamedDimsArray) = parent(x)
 unname(x::AbstractArray) = x
 
 """
-    names(A) -> Tuple
+    dimnames(A) -> Tuple
 
 Return the names of all the dimensions of the array `A`.
 """
-names(::Type{<:NamedDimsArray{L}}) where L = L
-names(::Type{<:AbstractArray{T, N}}) where {T, N} = ntuple(_->:_, N)
-names(x::T) where T<:AbstractArray = names(T)
+dimnames(::Type{<:NamedDimsArray{L}}) where L = L
+dimnames(::Type{<:AbstractArray{T, N}}) where {T, N} = ntuple(_->:_, N)
+dimnames(x::T) where T<:AbstractArray = dimnames(T)
 
 dim(a::NamedDimsArray{L}, name) where L = dim(L, name)
 
@@ -103,7 +103,7 @@ Base.axes(a::NamedDimsArray, d) = axes(parent(a), dim(a, d))
 
 
 function named_size(a::AbstractArray{T,N}) where {T,N}
-    L = names(a)
+    L = dimnames(a)
     NamedTuple{L, NTuple{N,Int}}(size(a))
 end
 function Base.similar(
@@ -157,7 +157,7 @@ order_named_inds(A; y=5) == (:, 5)
 
 This provides the core indexed lookup for `getindex` and `setindex` on the Array `A`
 """
-order_named_inds(A::AbstractArray; named_inds...) = order_named_inds(names(A); named_inds...)
+order_named_inds(A::AbstractArray; named_inds...) = order_named_inds(dimnames(A); named_inds...)
 
 ###################
 # getindex / view / dotview
@@ -183,7 +183,7 @@ for f in (:getindex, :view, :dotview)
         @propagate_inbounds function Base.$f(a::NamedDimsArray, inds...)
             # Some nonscalar case, will return an array, so need to give that names.
             data = Base.$f(parent(a), inds...)
-            L = remaining_dimnames_from_indexing(names(a), inds)
+            L = remaining_dimnames_from_indexing(dimnames(a), inds)
             return NamedDimsArray{L}(data)
         end
     end

test/broadcasting.jl

@@ -8,13 +8,13 @@ using Tracker
 
     @testset "standard case" begin
         @test nda .+ nda == 2ones(3)
-        @test names(nda .+ nda) == (:a,)
+        @test dimnames(nda .+ nda) == (:a,)
 
         @test nda .+ nda .+ nda == 3ones(3)
-        @test names(nda .+ nda .+ nda) == (:a,)
+        @test dimnames(nda .+ nda .+ nda) == (:a,)
 
         # in-place
-        @test names(nda .= 0 .* nda .+ 7) == (:a,)
+        @test dimnames(nda .= 0 .* nda .+ 7) == (:a,)
         @test unname(nda .= 0 .* nda .+ 7) == 7*ones(3)
     end
 
@@ -24,7 +24,7 @@ using Tracker
 
         lhs = ndx .+ ndy
         rhs = ndy .+ ndx
-        @test names(lhs) == (:x, :y) == names(rhs)
+        @test dimnames(lhs) == (:x, :y) == dimnames(rhs)
         @test lhs == 2ones(3, 5) == rhs
     end
 
@@ -41,15 +41,15 @@ using Tracker
             ones(3, 3, 3, 3)
         )
         @test lhs_sum == ones(3, 3, 3, 3)
-        @test names(lhs_sum) == (:a, :b, :c, :d)
+        @test dimnames(lhs_sum) == (:a, :b, :c, :d)
 
 
         rhs_sum = .+(
             zeros(3, 3, 3, 3),
             NamedDimsArray{(:w, :x, :y, :z)}(ones(3, 3, 3, 3))
         )
         @test rhs_sum == ones(3, 3, 3, 3)
-        @test names(rhs_sum) == (:w, :x, :y, :z)
+        @test dimnames(rhs_sum) == (:w, :x, :y, :z)
     end
 
     @testset "broadcasting" begin
@@ -61,9 +61,9 @@ using Tracker
         @test s .+ m == ones(3, 3) == m .+ s
         @test s .+ v .+ m == ones(3, 3) == m .+ s .+ v
 
-        @test names(v .+ m) == (:time, :value) == names(m .+ v)
-        @test names(s .+ m) == (:time, :value) == names(m .+ s)
-        @test names(s .+ v .+ m) == (:time, :value) == names(m .+ s .+ v)
+        @test dimnames(v .+ m) == (:time, :value) == dimnames(m .+ v)
+        @test dimnames(s .+ m) == (:time, :value) == dimnames(m .+ s)
+        @test dimnames(s .+ v .+ m) == (:time, :value) == dimnames(m .+ s .+ v)
     end
 
     @testset "Mixed array types" begin
@@ -82,15 +82,15 @@ using Tracker
 
             total = T1(ones(3, 6)) .+ T2(2ones(3, 6)) .+ T3(3ones(3, 6))
             @test total == 6ones(3, 6)
-            @test names(total) == (:foo, :bar)
+            @test dimnames(total) == (:foo, :bar)
         end
     end
 
     @testset "Regression test again #8b" begin
         # https://github.com/invenia/NamedDims.jl/issues/8#issuecomment-490124369
         nda = NamedDimsArray{(:x,:y,:z)}(ones(10,20,30))
         @test nda .+ ones(1,20) == 2ones(10,20,30)
-        @test names(nda .+ ones(1,20)) == (:x, :y, :z)
+        @test dimnames(nda .+ ones(1,20)) == (:x, :y, :z)
     end
 
     @testset "in-place assignment .=" begin
@@ -108,12 +108,12 @@ using Tracker
         @test_throws DimensionMismatch ac .= ab .+ ba
 
         # check that dest is written into:
-        @test names(z .= ab .+ ba') == (:a, :b)
+        @test dimnames(z .= ab .+ ba') == (:a, :b)
         @test z == (ab.data .+ ba.data')
         @test z isa Array  # has not itself magically gained names
 
-        @test names(z .= ab .+ a_) == (:a, :b)
-        @test names(a_ .= ba' .+ ab) == (:a, :b)
+        @test dimnames(z .= ab .+ a_) == (:a, :b)
+        @test dimnames(a_ .= ba' .+ ab) == (:a, :b)
     end
 
 end