Don't forward dename to parent by default, more generic Array conversion and copyto! (#44)

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.4.5"
+version = "0.5.0"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

src/abstractnameddimsarray.jl

@@ -20,8 +20,20 @@ DerivableInterfaces.interface(::Type{<:AbstractNamedDimsArray}) = NamedDimsArray
 
 # Output the dimension names.
 nameddimsindices(a::AbstractArray) = throw(MethodError(nameddimsindices, Tuple{typeof(a)}))
-# Unwrapping the names
-Base.parent(a::AbstractNamedDimsArray) = throw(MethodError(parent, Tuple{typeof(a)}))
+# Unwrapping the names (`NamedDimsArrays.jl` interface).
+# TODO: Use `IsNamed` trait?
+dename(a::AbstractNamedDimsArray) = throw(MethodError(dename, Tuple{typeof(a)}))
+function dename(a::AbstractNamedDimsArray, nameddimsindices)
+  return dename(aligndims(a, nameddimsindices))
+end
+function denamed(a::AbstractNamedDimsArray, nameddimsindices)
+  return dename(aligneddims(a, nameddimsindices))
+end
+
+unname(a::AbstractArray, nameddimsindices) = dename(a, nameddimsindices)
+unnamed(a::AbstractArray, nameddimsindices) = denamed(a, nameddimsindices)
+
+isnamed(::Type{<:AbstractNamedDimsArray}) = true
 
 nameddimsindices(a::AbstractArray, dim::Int) = nameddimsindices(a)[dim]
 
@@ -109,21 +121,6 @@ function to_nameddimsindices(a::AbstractNamedDimsArray, dims)
   return map(dim -> to_dimname(a, dim), dims)
 end
 
-# Unwrapping the names (`NamedDimsArrays.jl` interface).
-# TODO: Use `IsNamed` trait?
-dename(a::AbstractNamedDimsArray) = parent(a)
-function dename(a::AbstractNamedDimsArray, nameddimsindices)
-  return dename(aligndims(a, nameddimsindices))
-end
-function denamed(a::AbstractNamedDimsArray, nameddimsindices)
-  return dename(aligneddims(a, nameddimsindices))
-end
-
-unname(a::AbstractArray, nameddimsindices) = dename(a, nameddimsindices)
-unnamed(a::AbstractArray, nameddimsindices) = denamed(a, nameddimsindices)
-
-isnamed(::Type{<:AbstractNamedDimsArray}) = true
-
 # TODO: Move to `utils.jl` file.
 # TODO: Use `Base.indexin`?
 function getperm(x, y; isequal=isequal)
@@ -148,6 +145,36 @@ function Base.copy(a::AbstractNamedDimsArray)
   return constructorof(typeof(a))(copy(dename(a)), nameddimsindices(a))
 end
 
+function Base.copyto!(a_dest::AbstractNamedDimsArray, a_src::AbstractNamedDimsArray)
+  a′_dest = dename(a_dest)
+  # TODO: Use `denamed` to do the permutations lazily.
+  a′_src = dename(a_src, nameddimsindices(a_dest))
+  copyto!(a′_dest, a′_src)
+  return a_dest
+end
+
+# Conversion
+
+# Copied from `Base` (defined in abstractarray.jl).
+@noinline _checkaxs(axd, axs) =
+  axd == axs || throw(DimensionMismatch("axes must agree, got $axd and $axs"))
+function copyto_axcheck!(dest, src)
+  _checkaxs(axes(dest), axes(src))
+  return copyto!(dest, src)
+end
+
+# These are defined since the Base versions assume the eltype and ndims are known
+# at compile time, which isn't true for ITensors.
+Base.Array(a::AbstractNamedDimsArray) = Array(dename(a))
+Base.Array{T}(a::AbstractNamedDimsArray) where {T} = Array{T}(dename(a))
+Base.Array{T,N}(a::AbstractNamedDimsArray) where {T,N} = Array{T,N}(dename(a))
+Base.AbstractArray{T}(a::AbstractNamedDimsArray) where {T} = AbstractArray{T,ndims(a)}(a)
+function Base.AbstractArray{T,N}(a::AbstractNamedDimsArray) where {T,N}
+  dest = similar(a, T)
+  copyto_axcheck!(dename(dest), dename(a))
+  return dest
+end
+
 const NamedDimsIndices = Union{
   AbstractNamedUnitRange{<:Integer},AbstractNamedArray{<:Integer}
 }
@@ -380,7 +407,7 @@ function Base.getindex(a::NamedDimsCartesianIndices{N}, I::Vararg{Int,N}) where
 end
 
 nameddimsindices(I::NamedDimsCartesianIndices) = name.(I.indices)
-function Base.parent(I::NamedDimsCartesianIndices)
+function dename(I::NamedDimsCartesianIndices)
   return CartesianIndices(dename.(I.indices))
 end
 

src/nameddimsarray.jl

@@ -31,8 +31,9 @@ function NamedDimsArray(a::AbstractNamedDimsArray)
 end
 
 # Minimal interface.
-nameddimsindices(a::NamedDimsArray) = a.nameddimsindices
-Base.parent(a::NamedDimsArray) = a.parent
+nameddimsindices(a::NamedDimsArray) = getfield(a, :nameddimsindices)
+Base.parent(a::NamedDimsArray) = getfield(a, :parent)
+dename(a::NamedDimsArray) = parent(a)
 
 function TypeParameterAccessors.position(
   ::Type{<:AbstractNamedDimsArray}, ::typeof(parenttype)

test/test_basics.jl

@@ -71,6 +71,30 @@ using Test: @test, @test_throws, @testset
     @test_throws ErrorException NamedDimsArray(randn(4), namedoneto.((2, 2), ("i", "j")))
     @test_throws ErrorException NamedDimsArray(randn(2, 2), namedoneto.((2, 3), ("i", "j")))
 
+    a = randn(elt, 3, 4)
+    na = nameddimsarray(a, ("i", "j"))
+    a′ = Array(na)
+    @test eltype(a′) === elt
+    @test a′ isa Matrix{elt}
+    @test a′ == a
+
+    a = randn(elt, 3, 4)
+    na = nameddimsarray(a, ("i", "j"))
+    for a′ in (Array{Float32}(na), Matrix{Float32}(na))
+      @test eltype(a′) === Float32
+      @test a′ isa Matrix{Float32}
+      @test a′ == Float32.(a)
+    end
+
+    a = randn(elt, 2, 2, 2)
+    na = nameddimsarray(a, ("i", "j", "k"))
+    b = randn(elt, 2, 2, 2)
+    nb = nameddimsarray(b, ("k", "i", "j"))
+    copyto!(na, nb)
+    @test na == nb
+    @test dename(na) == dename(nb, ("i", "j", "k"))
+    @test dename(na) == permutedims(dename(nb), (2, 3, 1))
+
     a = randn(elt, 3, 4)
     na = nameddimsarray(a, ("i", "j"))
     i = namedoneto(3, "i")