Change nameddims to nameddimsarray (#30)

Author: mtfishman

Project.toml

@@ -1,7 +1,7 @@
 name = "NamedDimsArrays"
 uuid = "60cbd0c0-df58-4cb7-918c-6f5607b73fde"
 authors = ["ITensor developers <[email protected]> and contributors"]
-version = "0.3.12"
+version = "0.4.0"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

TODO.md

@@ -15,9 +15,9 @@ It could be written in terms of `align_getindex`/`align_view`.
 - `mapnameddimsindices(f, a::AbstractNamedDimsArray)` (rename `replacenameddimsindices(f, a)` to `mapnameddimsindices(f, a)`, or have both?)
 - `cat` (define `CatName` as a combination of the input names?).
 - `canonize`/`flatten_array_wrappers` (https://github.com/mcabbott/NamedPlus.jl/blob/v0.0.5/src/permute.jl#L207)
-  - `nameddims(PermutedDimsArray(a, perm), nameddimsindices)` -> `nameddims(a, nameddimsindices[invperm(perm)])`
-  - `nameddims(transpose(a), nameddimsindices)` -> `nameddims(a, reverse(nameddimsindices))`
-  - `Transpose(nameddims(a, nameddimsindices))` -> `nameddims(a, reverse(nameddimsindices))`
+  - `nameddimsarray(PermutedDimsArray(a, perm), nameddimsindices)` -> `nameddimsarray(a, nameddimsindices[invperm(perm)])`
+  - `nameddimsarray(transpose(a), nameddimsindices)` -> `nameddimsarray(a, reverse(nameddimsindices))`
+  - `Transpose(nameddimsarray(a, nameddimsindices))` -> `nameddimsarray(a, reverse(nameddimsindices))`
   - etc.
 - `MappedName(old_name, name)`, acts like `Name(name)` but keeps track of the old name.
   - `nameddimsmap(a, ::Pair...)`: `namedmap(named(randn(2, 2, 2, 2), i, j, k, l), i => k, j => l)`
@@ -33,8 +33,8 @@ It could be written in terms of `align_getindex`/`align_view`.
     - Same as `replacedims(a, dimname1 => dimname1′, dimname1′ => dimname1, dimname2 => dimname2′, dimname2′ => dimname2)`.
   - `transpose(f, a)` like the function form of `replace`.
 - `tr` based on `MappedName(old_name, name)`.
-- Slicing: `nameddims(a, "i", "j")[1:2, 1:2] = nameddims(a[1:2, 1:2], Name(named(1:2, "i")), Name(named(1:2, "j")))`, i.e.
+- Slicing: `nameddimsarray(a, "i", "j")[1:2, 1:2] = nameddimsarray(a[1:2, 1:2], Name(named(1:2, "i")), Name(named(1:2, "j")))`, i.e.
   the parent gets sliced and the new dimensions names are the named slice.
   - Should `NamedDimsArray` store the named axes rather than just the dimension names?
-  - Should `NamedDimsArray` have special axes types so that `axes(nameddims(a, "i", "j")) == axes(nameddims(a', "j", "i"))`,
+  - Should `NamedDimsArray` have special axes types so that `axes(nameddimsarray(a, "i", "j")) == axes(nameddimsarray(a', "j", "i"))`,
     i.e. equality is based on `issetequal` and not dependent on the ordering of the dimensions?

ext/NamedDimsArraysBlockArraysExt/NamedDimsArraysBlockArraysExt.jl

@@ -2,7 +2,7 @@ module NamedDimsArraysBlockArraysExt
 using ArrayLayouts: ArrayLayouts
 using BlockArrays: Block, BlockRange
 using NamedDimsArrays:
-  AbstractNamedDimsArray, AbstractNamedUnitRange, getindex_named, view_nameddims
+  AbstractNamedDimsArray, AbstractNamedUnitRange, getindex_named, view_nameddimsarray
 
 function Base.getindex(r::AbstractNamedUnitRange{<:Integer}, I::Block{1})
   # TODO: Use `Derive.@interface NamedArrayInterface() r[I]` instead.
@@ -18,17 +18,17 @@ const BlockIndex{N} = Union{Block{N},BlockRange{N},AbstractVector{<:Block{N}}}
 
 function Base.view(a::AbstractNamedDimsArray, I1::Block{1}, Irest::BlockIndex{1}...)
   # TODO: Use `Derive.@interface NamedDimsArrayInterface() r[I]` instead.
-  return view_nameddims(a, I1, Irest...)
+  return view_nameddimsarray(a, I1, Irest...)
 end
 
 function Base.view(a::AbstractNamedDimsArray, I::Block)
   # TODO: Use `Derive.@interface NamedDimsArrayInterface() r[I]` instead.
-  return view_nameddims(a, Tuple(I)...)
+  return view_nameddimsarray(a, Tuple(I)...)
 end
 
 function Base.view(a::AbstractNamedDimsArray, I1::BlockIndex{1}, Irest::BlockIndex{1}...)
   # TODO: Use `Derive.@interface NamedDimsArrayInterface() r[I]` instead.
-  return view_nameddims(a, I1, Irest...)
+  return view_nameddimsarray(a, I1, Irest...)
 end
 
 # Fix ambiguity error.

src/NamedDimsArrays.jl

@@ -1,6 +1,6 @@
 module NamedDimsArrays
 
-export NamedDimsArray, aligndims, named, nameddims
+export NamedDimsArray, aligndims, named, nameddimsarray
 
 include("isnamed.jl")
 include("randname.jl")

src/abstractnameddimsarray.jl

@@ -151,9 +151,9 @@ const NamedDimsAxis = AbstractNamedUnitRange{
 }
 
 # Generic constructor.
-function nameddims(a::AbstractArray, nameddimsindices)
+function nameddimsarray(a::AbstractArray, nameddimsindices)
   if iszero(ndims(a))
-    return constructorof_nameddims(typeof(a))(a, nameddimsindices)
+    return constructorof_nameddimsarray(typeof(a))(a, nameddimsindices)
   end
   # TODO: Check the shape of `nameddimsindices` matches the shape of `a`.
   arrtype = mapreduce(nameddimsarraytype, combine_nameddimsarraytype, nameddimsindices)
@@ -251,17 +251,19 @@ to_nameddimsaxis(I::NamedDimsIndices) = named(dename(only(axes(I))), I)
 # Interface inspired by [ConstructionBase.constructorof](https://github.com/JuliaObjects/ConstructionBase.jl).
 constructorof(type::Type{<:AbstractArray}) = unspecify_type_parameters(type)
 
-constructorof_nameddims(type::Type{<:AbstractNamedDimsArray}) = constructorof(type)
-constructorof_nameddims(type::Type{<:AbstractArray}) = NamedDimsArray
+constructorof_nameddimsarray(type::Type{<:AbstractNamedDimsArray}) = constructorof(type)
+constructorof_nameddimsarray(type::Type{<:AbstractArray}) = NamedDimsArray
 
-function similar_nameddims(a::AbstractNamedDimsArray, elt::Type, inds)
+function similar_nameddimsarray(a::AbstractNamedDimsArray, elt::Type, inds)
   ax = to_nameddimsaxes(inds)
   return constructorof(typeof(a))(similar(dename(a), elt, dename.(Tuple(ax))), name.(ax))
 end
 
-function similar_nameddims(a::AbstractArray, elt::Type, inds)
+function similar_nameddimsarray(a::AbstractArray, elt::Type, inds)
   ax = to_nameddimsaxes(inds)
-  return constructorof_nameddims(typeof(a))(similar(a, elt, dename.(Tuple(ax))), name.(ax))
+  return constructorof_nameddimsarray(typeof(a))(
+    similar(a, elt, dename.(Tuple(ax))), name.(ax)
+  )
 end
 
 # Base.similar gets the eltype at compile time.
@@ -272,11 +274,11 @@ end
 function Base.similar(
   a::AbstractArray, elt::Type, inds::Tuple{NamedDimsIndices,Vararg{NamedDimsIndices}}
 )
-  return similar_nameddims(a, elt, inds)
+  return similar_nameddimsarray(a, elt, inds)
 end
 
 function Base.similar(a::AbstractArray, elt::Type, inds::NaiveOrderedSet)
-  return similar_nameddims(a, elt, inds)
+  return similar_nameddimsarray(a, elt, inds)
 end
 
 function setnameddimsindices(a::AbstractNamedDimsArray, nameddimsindices)
@@ -506,15 +508,15 @@ function Base.view(a::AbstractArray, I1::NamedViewIndex, Irest::NamedViewIndex..
   I = (I1, Irest...)
   sub_dims = filter(dim -> I[dim] isa AbstractArray, ntuple(identity, ndims(a)))
   sub_nameddimsindices = map(dim -> I[dim], sub_dims)
-  return nameddims(view(a, dename.(I)...), sub_nameddimsindices)
+  return nameddimsarray(view(a, dename.(I)...), sub_nameddimsindices)
 end
 
 function Base.getindex(a::AbstractArray, I1::NamedViewIndex, Irest::NamedViewIndex...)
   return copy(view(a, I1, Irest...))
 end
 
 function Base.view(a::AbstractArray, I1::Name, Irest::Name...)
-  return nameddims(a, name.((I1, Irest...)))
+  return nameddimsarray(a, name.((I1, Irest...)))
 end
 
 function Base.view(a::AbstractNamedDimsArray, I1::Name, Irest::Name...)
@@ -536,7 +538,7 @@ function Base.view(a::AbstractNamedDimsArray, I1::NamedViewIndex, Irest::NamedVi
   subinds = map(nameddimsindices(a), I) do dimname, i
     return checked_indexin(dename(i), dename(dimname))
   end
-  return constructorof_nameddims(typeof(a))(
+  return constructorof_nameddimsarray(typeof(a))(
     view(dename(a), subinds...), sub_nameddimsindices
   )
 end
@@ -550,22 +552,22 @@ end
 # Repeated definition of `Base.ViewIndex`.
 const ViewIndex = Union{Real,AbstractArray}
 
-function view_nameddims(a::AbstractArray, I...)
+function view_nameddimsarray(a::AbstractArray, I...)
   sub_dims = filter(dim -> !(I[dim] isa Real), ntuple(identity, ndims(a)))
   sub_nameddimsindices = map(dim -> nameddimsindices(a, dim)[I[dim]], sub_dims)
   return constructorof(typeof(a))(view(dename(a), I...), sub_nameddimsindices)
 end
 
 function Base.view(a::AbstractNamedDimsArray, I::ViewIndex...)
-  return view_nameddims(a, I...)
+  return view_nameddimsarray(a, I...)
 end
 
-function getindex_nameddims(a::AbstractArray, I...)
+function getindex_nameddimsarray(a::AbstractArray, I...)
   return copy(view(a, I...))
 end
 
 function Base.getindex(a::AbstractNamedDimsArray, I::ViewIndex...)
-  return getindex_nameddims(a, I...)
+  return getindex_nameddimsarray(a, I...)
 end
 
 function Base.setindex!(
@@ -624,7 +626,7 @@ function aligneddims(a::AbstractArray, dims)
       "Dimension name mismatch $(nameddimsindices(a)), $(new_nameddimsindices)."
     ),
   )
-  return constructorof_nameddims(typeof(a))(
+  return constructorof_nameddimsarray(typeof(a))(
     PermutedDimsArray(dename(a), perm), new_nameddimsindices
   )
 end
@@ -659,7 +661,7 @@ for (f, f′) in [(:rand, :_rand), (:randn, :_randn)]
     )
       ax = to_nameddimsaxes(inds)
       a = $f′(rng, elt, dename.(ax))
-      return nameddims(a, name.(ax))
+      return nameddimsarray(a, name.(ax))
     end
     function Base.$f(
       rng::AbstractRNG,
@@ -692,13 +694,13 @@ for f in [:zeros, :ones]
     )
       ax = to_nameddimsaxes(inds)
       a = $f(elt, dename.(ax))
-      return nameddims(a, name.(ax))
+      return nameddimsarray(a, name.(ax))
     end
     function Base.$f(
       elt::Type{<:Number}, dims::Tuple{AbstractNamedInteger,Vararg{AbstractNamedInteger}}
     )
       a = $f(elt, dename.(dims))
-      return nameddims(a, Base.oneto.(dims))
+      return nameddimsarray(a, Base.oneto.(dims))
     end
   end
   for dimtype in [:AbstractNamedInteger, :NamedDimsIndices]
@@ -715,11 +717,11 @@ end
   function Base.fill(value, inds::Tuple{NamedDimsIndices,Vararg{NamedDimsIndices}})
     ax = to_nameddimsaxes(inds)
     a = fill(value, dename.(ax))
-    return nameddims(a, name.(ax))
+    return nameddimsarray(a, name.(ax))
   end
   function Base.fill(value, dims::Tuple{AbstractNamedInteger,Vararg{AbstractNamedInteger}})
     a = fill(value, dename.(dims))
-    return nameddims(a, Base.oneto.(dims))
+    return nameddimsarray(a, Base.oneto.(dims))
   end
 end
 for dimtype in [:AbstractNamedInteger, :NamedDimsIndices]
@@ -896,7 +898,7 @@ function Base.show(io::IO, mime::MIME"text/plain", a::AbstractNamedDimsArray)
 end
 
 function Base.show(io::IO, a::AbstractNamedDimsArray)
-  print(io, "nameddims(")
+  print(io, "nameddimsarray(")
   show(io, dename(a))
   print(io, ", ", nameddimsindices(a), ")")
   return nothing

src/adapt.jl

@@ -1,5 +1,5 @@
 using Adapt: Adapt, adapt
 
 function Adapt.adapt_structure(to, a::AbstractNamedDimsArray)
-  return nameddims(adapt(to, dename(a)), nameddimsindices(a))
+  return nameddimsarray(adapt(to, dename(a)), nameddimsindices(a))
 end

src/tensoralgebra.jl

@@ -95,7 +95,7 @@ function TensorAlgebra.fusedims(na::AbstractNamedDimsArray, fusions::Pair...)
   end
   perm = blockedperm(na, nameddimsindices_fuse...)
   a_fused = fusedims(unname(na), perm)
-  return nameddims(a_fused, nameddimsindices_fused)
+  return nameddimsarray(a_fused, nameddimsindices_fused)
 end
 
 function TensorAlgebra.splitdims(na::AbstractNamedDimsArray, splitters::Pair...)
@@ -116,7 +116,7 @@ function TensorAlgebra.splitdims(na::AbstractNamedDimsArray, splitters::Pair...)
     names_split[fused_dim] = split_names
   end
   names_split = reduce((x, y) -> (x..., y...), names_split)
-  return nameddims(a_split, names_split)
+  return nameddimsarray(a_split, names_split)
 end
 
 function TensorAlgebra.qr(
@@ -140,8 +140,8 @@ function TensorAlgebra.qr(
     to_nameddimsindices(a, nameddimsindices_codomain)..., namedindices_q
   )
   nameddimsindices_r = (namedindices_r, to_nameddimsindices(a, nameddimsindices_domain)...)
-  q = nameddims(q_unnamed, nameddimsindices_q)
-  r = nameddims(r_unnamed, nameddimsindices_r)
+  q = nameddimsarray(q_unnamed, nameddimsindices_q)
+  r = nameddimsarray(r_unnamed, nameddimsindices_r)
   return q, r
 end
 
@@ -176,9 +176,9 @@ function TensorAlgebra.svd(
   )
   nameddimsindices_s = (namedindices_u, namedindices_v)
   nameddimsindices_v = (namedindices_v, to_nameddimsindices(a, nameddimsindices_domain)...)
-  u = nameddims(u_unnamed, nameddimsindices_u)
-  s = nameddims(s_unnamed, nameddimsindices_s)
-  v = nameddims(v_unnamed, nameddimsindices_v)
+  u = nameddimsarray(u_unnamed, nameddimsindices_u)
+  s = nameddimsarray(s_unnamed, nameddimsindices_s)
+  v = nameddimsarray(v_unnamed, nameddimsindices_v)
   return u, s, v
 end
 

test/test_adapt.jl

@@ -1,12 +1,10 @@
 using Adapt: adapt
-using NamedDimsArrays: nameddims
+using NamedDimsArrays: nameddimsarray
 using Test: @test, @testset
 
-using NamedDimsArrays: nameddimsindices
-
 @testset "Adapt (eltype=$elt)" for elt in
                                    (Float32, Float64, Complex{Float32}, Complex{Float64})
-  na = nameddims(randn(2, 2), ("i", "j"))
+  na = nameddimsarray(randn(2, 2), ("i", "j"))
   na_complex = adapt(Array{complex(elt)}, na)
   @test na ≈ na_complex
   @test eltype(na_complex) === complex(elt)

test/test_basics.jl

@@ -22,7 +22,7 @@ using NamedDimsArrays:
   mapnameddimsindices,
   name,
   named,
-  nameddims,
+  nameddimsarray,
   nameddimsindices,
   namedoneto,
   replacenameddimsindices,
@@ -36,7 +36,7 @@ using Test: @test, @test_throws, @testset
     elt = Float64
     a = randn(elt, 3, 4)
     @test !isnamed(a)
-    na = nameddims(a, ("i", "j"))
+    na = nameddimsarray(a, ("i", "j"))
     @test na isa NamedDimsMatrix{elt,Matrix{elt}}
     @test na isa AbstractNamedDimsMatrix{elt}
     @test na isa NamedDimsArray{elt}
@@ -171,8 +171,8 @@ using Test: @test, @test_throws, @testset
     @test unname(na′) isa PermutedDimsArray{elt}
     @test a == permutedims(unname(na′), (2, 1))
 
-    na = nameddims(randn(elt, 2, 3), (:i, :j))
-    nb = nameddims(randn(elt, 3, 2), (:j, :i))
+    na = nameddimsarray(randn(elt, 2, 3), (:i, :j))
+    nb = nameddimsarray(randn(elt, 3, 2), (:j, :i))
     nc = zeros(elt, named.((2, 3), (:i, :j)))
     Is = eachindex(na, nb)
     @test Is isa NamedDimsCartesianIndices{2}
@@ -184,25 +184,25 @@ using Test: @test, @test_throws, @testset
     end
     @test dename(nc, (:i, :j)) ≈ dename(na, (:i, :j)) + dename(nb, (:i, :j))
 
-    a = nameddims(randn(elt, 2, 3), (:i, :j))
-    b = nameddims(randn(elt, 3, 2), (:j, :i))
+    a = nameddimsarray(randn(elt, 2, 3), (:i, :j))
+    b = nameddimsarray(randn(elt, 3, 2), (:j, :i))
     c = a + b
     @test dename(c, (:i, :j)) ≈ dename(a, (:i, :j)) + dename(b, (:i, :j))
     c = a .+ b
     @test dename(c, (:i, :j)) ≈ dename(a, (:i, :j)) + dename(b, (:i, :j))
     c = map(+, a, b)
     @test dename(c, (:i, :j)) ≈ dename(a, (:i, :j)) + dename(b, (:i, :j))
-    c = nameddims(Array{elt}(undef, 2, 3), (:i, :j))
+    c = nameddimsarray(Array{elt}(undef, 2, 3), (:i, :j))
     c = map!(+, c, a, b)
     @test dename(c, (:i, :j)) ≈ dename(a, (:i, :j)) + dename(b, (:i, :j))
     c = a .+ 2 .* b
     @test dename(c, (:i, :j)) ≈ dename(a, (:i, :j)) + 2 * dename(b, (:i, :j))
-    c = nameddims(Array{elt}(undef, 2, 3), (:i, :j))
+    c = nameddimsarray(Array{elt}(undef, 2, 3), (:i, :j))
     c .= a .+ 2 .* b
     @test dename(c, (:i, :j)) ≈ dename(a, (:i, :j)) + 2 * dename(b, (:i, :j))
 
     # Regression test for proper permutations.
-    a = nameddims(randn(elt, 2, 3, 4), (:i, :j, :k))
+    a = nameddimsarray(randn(elt, 2, 3, 4), (:i, :j, :k))
     I = (:i => 2, :j => 3, :k => 4)
     for I′ in Combinatorics.permutations(I)
       @test a[I′...] == a[2, 3, 4]

test/test_blockarraysext.jl

@@ -1,14 +1,14 @@
 using BlockArrays: Block
 using BlockSparseArrays: BlockSparseArray
-using NamedDimsArrays: dename, nameddims, nameddimsindices
+using NamedDimsArrays: dename, nameddimsarray, nameddimsindices
 using Test: @test, @testset
 
 @testset "NamedDimsArraysBlockArraysExt" begin
   elt = Float64
   a = BlockSparseArray{elt}([2, 3], [2, 3])
   a[Block(2, 1)] = randn(elt, 3, 2)
   a[Block(1, 2)] = randn(elt, 2, 3)
-  n = nameddims(a, ("i", "j"))
+  n = nameddimsarray(a, ("i", "j"))
   i, j = nameddimsindices(n)
   @test dename(n[i[Block(2)], j[Block(1)]]) == a[Block(2, 1)]
   @test dename(n[Block(2), Block(1)]) == a[Block(2, 1)]