Upgrade to NamedDimsArrays.jl v0.13

Project.toml

@@ -1,7 +1,7 @@
 name = "ITensorNetworksNext"
 uuid = "302f2e75-49f0-4526-aef7-d8ba550cb06c"
 authors = ["ITensor developers <support@itensor.org> and contributors"]
-version = "0.3.2"
+version = "0.3.3"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
@@ -43,7 +43,7 @@ FunctionImplementations = "0.3"
 Graphs = "1.13.1"
 LinearAlgebra = "1.10"
 MacroTools = "0.5.16"
-NamedDimsArrays = "0.12"
+NamedDimsArrays = "0.13"
 NamedGraphs = "0.6.9, 0.7, 0.8"
 SimpleTraits = "0.9.5"
 SplitApplyCombine = "1.2.3"

src/LazyNamedDimsArrays/evaluation_order.jl

@@ -1,4 +1,4 @@
-using NamedDimsArrays: dename, inds
+using NamedDimsArrays: denamed, inds
 using TermInterface: arguments, arity, operation
 
 # The time complexity of evaluating `f(args...)`.
@@ -18,16 +18,16 @@ using NamedDimsArrays: AbstractNamedDimsArray
 function time_complexity(
         ::typeof(*), t1::AbstractNamedDimsArray, t2::AbstractNamedDimsArray
     )
-    return prod(length ∘ dename, (inds(t1) ∪ inds(t2)))
+    return prod(length ∘ denamed, (inds(t1) ∪ inds(t2)))
 end
 function time_complexity(
         ::typeof(+), t1::AbstractNamedDimsArray, t2::AbstractNamedDimsArray
     )
     @assert issetequal(inds(t1), inds(t2))
-    return prod(dename, size(t1))
+    return prod(denamed, size(t1))
 end
 function time_complexity(::typeof(*), c::Number, t::AbstractNamedDimsArray)
-    return prod(dename, size(t))
+    return prod(denamed, size(t))
 end
 function time_complexity(::typeof(*), t::AbstractNamedDimsArray, c::Number)
     return time_complexity(*, c, t)

src/LazyNamedDimsArrays/lazyinterface.jl

@@ -1,4 +1,4 @@
-using NamedDimsArrays: dename
+using NamedDimsArrays: denamed
 using TermInterface: iscall, maketerm, operation, sorted_arguments
 using WrappedUnions: unwrap
 
@@ -224,11 +224,11 @@ function inds_lazy(a)
         return error("Variant not supported.")
     end
 end
-const dename_lazy = lazy_style(dename)
-function dename_lazy(a)
+const denamed_lazy = lazy_style(denamed)
+function denamed_lazy(a)
     u = unwrap(a)
     if !iscall(u)
-        return dename(u)
+        return denamed(u)
     else
         return error("Variant not supported.")
     end

src/LazyNamedDimsArrays/lazynameddimsarray.jl

@@ -24,7 +24,7 @@ lazy(a::AbstractNamedDimsArray) = LazyNamedDimsArray(a)
 lazy(a::Mul{<:LazyNamedDimsArray}) = LazyNamedDimsArray(a)
 
 NamedDimsArrays.inds(a::LazyNamedDimsArray) = inds_lazy(a)
-NamedDimsArrays.dename(a::LazyNamedDimsArray) = dename_lazy(a)
+NamedDimsArrays.denamed(a::LazyNamedDimsArray) = denamed_lazy(a)
 
 # Broadcasting
 function Base.BroadcastStyle(::Type{<:LazyNamedDimsArray})

src/LazyNamedDimsArrays/nameddimsarraysextensions.jl

@@ -1,11 +1,11 @@
-using NamedDimsArrays: NamedDimsArray, dename, inds
+using NamedDimsArrays: NamedDimsArray, denamed, inds
 # Defined to avoid type piracy.
 # TODO: Define a proper hash function
 # in NamedDimsArrays.jl, maybe one that is
 # independent of the order of dimensions.
 function _hash(a::NamedDimsArray, h::UInt64)
     h = hash(:NamedDimsArray, h)
-    h = hash(dename(a), h)
+    h = hash(denamed(a), h)
     for i in inds(a)
         h = hash(i, h)
     end

src/LazyNamedDimsArrays/symbolicnameddimsarray.jl

@@ -1,22 +1,22 @@
-using NamedDimsArrays: NamedDimsArray, dename, inds, nameddims
+using NamedDimsArrays: NamedDimsArray, denamed, inds, nameddims
 
 const SymbolicNamedDimsArray{T, N, Parent <: SymbolicArray{T, N}, DimNames} =
     NamedDimsArray{T, N, Parent, DimNames}
 function symnameddims(name, dims)
-    return lazy(nameddims(SymbolicArray(name, dename.(dims)), dims))
+    return lazy(nameddims(SymbolicArray(name, denamed.(dims)), dims))
 end
 symnameddims(name) = symnameddims(name, ())
 using AbstractTrees: AbstractTrees
 function AbstractTrees.printnode(io::IO, a::SymbolicNamedDimsArray)
-    print(io, symname(dename(a)))
+    print(io, symname(denamed(a)))
     if ndims(a) > 0
         print(io, "[", join(dimnames(a), ","), "]")
     end
     return nothing
 end
 printnode_nameddims(io::IO, a::SymbolicNamedDimsArray) = AbstractTrees.printnode(io, a)
 function Base.:(==)(a::SymbolicNamedDimsArray, b::SymbolicNamedDimsArray)
-    return issetequal(inds(a), inds(b)) && dename(a) == dename(b)
+    return issetequal(inds(a), inds(b)) && denamed(a) == denamed(b)
 end
 Base.:*(a::SymbolicNamedDimsArray, b::SymbolicNamedDimsArray) = lazy(a) * lazy(b)
 Base.:*(a::SymbolicNamedDimsArray, b::LazyNamedDimsArray) = lazy(a) * b

src/TensorNetworkGenerators/ising_network.jl

@@ -2,7 +2,7 @@ using DiagonalArrays: DiagonalArray
 using Graphs: degree, dst, edges, src
 using ..ITensorNetworksNext: @preserve_graph
 using LinearAlgebra: Diagonal, eigen
-using NamedDimsArrays: apply, dename, inds, operator, randname
+using NamedDimsArrays: apply, denamed, inds, operator, randname
 using NamedGraphs.GraphsExtensions: vertextype
 
 function sqrt_ising_bond(β; J = one(β), h = zero(β), deg1::Integer, deg2::Integer)
@@ -33,7 +33,7 @@ function ising_network(
     f̃(e) = get(() -> l̃[reverse(e)], l̃, e)
     tn = delta_network(f̃, elt, g)
     for v in sz_vertices
-        a = DiagonalArray(elt[1, -1], dename.(inds(tn[v])))
+        a = DiagonalArray(elt[1, -1], denamed.(inds(tn[v])))
         tn[v] = a[inds(tn[v])...]
     end
     for e in edges(tn)

test/Project.toml

@@ -29,7 +29,7 @@ Dictionaries = "0.4.5"
 Graphs = "1.13.1"
 ITensorBase = "0.3, 0.4"
 ITensorNetworksNext = "0.3"
-NamedDimsArrays = "0.12"
+NamedDimsArrays = "0.13"
 NamedGraphs = "0.6.8, 0.7, 0.8"
 QuadGK = "2.11.2"
 SafeTestsets = "0.1"

test/test_lazynameddimsarrays.jl

@@ -2,7 +2,8 @@ using AbstractTrees: AbstractTrees, print_tree, printnode
 using Base.Broadcast: materialize
 using ITensorNetworksNext.LazyNamedDimsArrays: LazyNamedDimsArrays, LazyNamedDimsArray,
     Mul, SymbolicArray, ismul, lazy, substitute, symnameddims
-using NamedDimsArrays: NamedDimsArray, @names, dename, dimnames, inds, nameddims, namedoneto
+using NamedDimsArrays: NamedDimsArray, @names, denamed, dimnames, inds, nameddims,
+    namedoneto
 using TermInterface: arguments, arity, children, head, iscall, isexpr, maketerm, operation,
     sorted_arguments, sorted_children
 using Test: @test, @test_throws, @testset
@@ -93,10 +94,10 @@ using WrappedUnions: unwrap
         a1, a2, a3 = symnameddims.((:a1, :a2, :a3))
         @test a1 isa LazyNamedDimsArray
         @test unwrap(a1) isa NamedDimsArray
-        @test dename(a1) isa SymbolicArray
-        @test dename(unwrap(a1)) isa SymbolicArray
-        @test dename(unwrap(a1)) == SymbolicArray(:a1, ())
-        @test isequal(dename(unwrap(a1)), SymbolicArray(:a1, ()))
+        @test denamed(a1) isa SymbolicArray
+        @test denamed(unwrap(a1)) isa SymbolicArray
+        @test denamed(unwrap(a1)) == SymbolicArray(:a1, ())
+        @test isequal(denamed(unwrap(a1)), SymbolicArray(:a1, ()))
         @test inds(a1) == ()
         @test dimnames(a1) == ()