undef init

Author: ogauthe

src/fusiontensor/array_cast.jl

@@ -64,7 +64,7 @@ function to_fusiontensor_no_checknorm(
   codomain_legs::Tuple{Vararg{AbstractGradedUnitRange}},
   domain_legs::Tuple{Vararg{AbstractGradedUnitRange}},
 )
-  ft = FusionTensor(eltype(blockarray), codomain_legs, domain_legs)
+  ft = FusionTensor{eltype(blockarray)}(undef, codomain_legs, domain_legs)
   for (f1, f2) in keys(trees_block_mapping(ft))
     b = findblock(ft, f1, f2)
     ft[f1, f2] = contract_fusion_trees(blockarray[b], f1, f2)

src/fusiontensor/base_interface.jl

@@ -104,7 +104,7 @@ function Base.similar(
   return similar(ft, T, tuplemortar(new_axes))
 end
 function Base.similar(::FusionTensor, ::Type{T}, new_axes::BlockedTuple{2}) where {T}
-  return FusionTensor(T, new_axes)
+  return FusionTensor{T}(undef, new_axes)
 end
 
 Base.show(io::IO, ft::FusionTensor) = print(io, "$(ndims(ft))-dim FusionTensor")

src/fusiontensor/fusiontensor.jl

@@ -176,12 +176,12 @@ function FusionTensor(
 end
 
 # empty matrix
-function FusionTensor(elt::Type, legs::FusionTensorAxes)
+function FusionTensor{T}(::UndefInitializer, legs::FusionTensorAxes) where {T}
   S = sector_type(legs)
   row_axis, codomain_trees_to_ranges = fuse_axes(S, codomain(legs))
   col_axis, domain_trees_to_ranges = flip_domain(fuse_axes(S, dual.(domain(legs)))...)
 
-  mat = initialize_data_matrix(elt, row_axis, col_axis)
+  mat = initialize_data_matrix(T, row_axis, col_axis)
   tree_to_block_mapping = intersect_codomain_domain(
     codomain_trees_to_ranges, domain_trees_to_ranges
   )
@@ -191,7 +191,7 @@ end
 #constructor from precomputed data_matrix
 function FusionTensor(mat::AbstractMatrix, legs::FusionTensorAxes)
   # init with empty data_matrix to construct trees_block_mapping
-  ft = FusionTensor(eltype(mat), legs)
+  ft = FusionTensor{eltype(mat)}(undef, legs)
   for b in eachblockstoredindex(mat)
     b in eachblockstoredindex(data_matrix(ft)) ||
       throw(ArgumentError("matrix block $b is not allowed"))
@@ -201,6 +201,9 @@ function FusionTensor(mat::AbstractMatrix, legs::FusionTensorAxes)
 end
 
 FusionTensor(x, legs::BlockedTuple{2}) = FusionTensor(x, FusionTensorAxes(legs))
+function FusionTensor{T}(x, legs::BlockedTuple{2}) where {T}
+  return FusionTensor{T}(x, FusionTensorAxes(legs))
+end
 
 # constructor from split axes
 function FusionTensor(
@@ -211,15 +214,25 @@ function FusionTensor(
   return FusionTensor(x, tuplemortar((codomain_legs, domain_legs)))
 end
 
+function FusionTensor{T}(
+  x,
+  codomain_legs::Tuple{Vararg{AbstractGradedUnitRange}},
+  domain_legs::Tuple{Vararg{AbstractGradedUnitRange}},
+) where {T}
+  return FusionTensor{T}(x, tuplemortar((codomain_legs, domain_legs)))
+end
+
 # specific constructors
-Base.zeros(::Type{T}, fta::FusionTensorAxes) where {T} = FusionTensor(T, fta)
+function Base.zeros(::Type{T}, fta::FusionTensorAxes) where {T}
+  ft = FusionTensor{T}(undef, fta)
+  map(m -> fill!(m, zero(T)), eachstoredblock(data_matrix(ft)))
+  return ft
+end
 Base.zeros(fta::FusionTensorAxes) = zeros(Float64, fta)
 
 function Base.randn(rng::AbstractRNG, ::Type{T}, fta::FusionTensorAxes) where {T}
-  ft = FusionTensor(T, fta)
-  for m in eachstoredblock(data_matrix(ft))
-    randn!(rng, m)
-  end
+  ft = FusionTensor{T}(undef, fta)
+  map(m -> randn!(rng, m), eachstoredblock(data_matrix(ft)))
   return ft
 end
 Base.randn(rng::AbstractRNG, fta::FusionTensorAxes) = randn(rng, Float64, fta)
@@ -230,7 +243,7 @@ function FusionTensor{T}(
   s::UniformScaling, codomain_legs::Tuple{Vararg{AbstractGradedUnitRange}}
 ) where {T}
   fta = FusionTensorAxes(codomain_legs, dual.(codomain_legs))
-  ft = FusionTensor(T, fta)
+  ft = FusionTensor{T}(undef, fta)
   for m in eachstoredblock(data_matrix(ft))
     m .= s(size(m, 1))
   end

src/permutedims/permutedims.jl

@@ -38,14 +38,15 @@ function fusiontensor_permutedims(ft, biperm::BlockedPermutation{2})
     end
   end
 
-  new_ft = FusionTensor(eltype(ft), axes(ft)[biperm])
+  new_ft = FusionTensor{eltype(ft)}(undef, axes(ft)[biperm])
   fusiontensor_permutedims!(new_ft, ft, Tuple(biperm))
   return new_ft
 end
 
 function fusiontensor_permutedims!(
   new_ft::FusionTensor{T,N}, old_ft::FusionTensor{T,N}, flatperm::NTuple{N,Integer}
 ) where {T,N}
+  map(m -> fill!(m, zero(T)), eachstoredblock(data_matrix(new_ft)))
   unitary = compute_unitary(new_ft, old_ft, flatperm)
   for p in unitary
     old_trees, new_trees = first(p)

test/test_basics.jl

@@ -38,13 +38,13 @@ include("setup.jl")
   g2 = dual(gradedrange([U1(0) => 2, U1(1) => 2, U1(3) => 1]))
 
   fta = FusionTensorAxes((g1,), (g2,))
-  ft0 = FusionTensor(Float64, fta)
+  ft0 = FusionTensor{Float64}(undef, fta)
   @test ft0 isa FusionTensor
   @test space_isequal(codomain_axis(ft0), g1)
   @test space_isequal(domain_axis(ft0), g2)
 
   # check dual convention when initializing data_matrix
-  ft0 = FusionTensor(Float64, (g1,), (g2,))
+  ft0 = FusionTensor{Float64}(undef, (g1,), (g2,))
   @test ft0 isa FusionTensor
   @test space_isequal(codomain_axis(ft0), g1)
   @test space_isequal(domain_axis(ft0), g2)
@@ -154,7 +154,7 @@ end
   g1 = gradedrange([U1(0) => 1, U1(1) => 2, U1(2) => 3])
 
   # one row axis
-  ft1 = FusionTensor(Float64, (g1,), ())
+  ft1 = FusionTensor{Float64}(undef, (g1,), ())
   @test ndims_codomain(ft1) == 1
   @test ndims_domain(ft1) == 0
   @test ndims(ft1) == 1
@@ -164,7 +164,7 @@ end
   @test sector_type(ft1) === sector_type(g1)
 
   # one column axis
-  ft2 = FusionTensor(Float64, (), (g1,))
+  ft2 = FusionTensor{Float64}(undef, (), (g1,))
   @test ndims_codomain(ft2) == 0
   @test ndims_domain(ft2) == 1
   @test ndims(ft2) == 1
@@ -174,7 +174,7 @@ end
   @test sector_type(ft2) === sector_type(g1)
 
   # zero axis
-  ft3 = FusionTensor(Float64, (), ())
+  ft3 = FusionTensor{Float64}(undef, (), ())
   @test ndims_codomain(ft3) == 0
   @test ndims_domain(ft3) == 0
   @test ndims(ft3) == 0
@@ -189,7 +189,7 @@ end
   g2 = gradedrange([U1(0) => 2, U1(1) => 2, U1(3) => 1])
   g3 = gradedrange([U1(-1) => 1, U1(0) => 2, U1(1) => 1])
   g4 = gradedrange([U1(-1) => 1, U1(0) => 1, U1(1) => 1])
-  ft3 = FusionTensor(Float64, (g1, g2), (g3, g4))
+  ft3 = FusionTensor{Float64}(undef, (g1, g2), (g3, g4))
   @test isnothing(check_sanity(ft3))
 
   ft4 = +ft3
@@ -268,7 +268,7 @@ end
   @test space_isequal(dual(g4), codomain_axes(ad)[2])
   @test isnothing(check_sanity(ad))
 
-  ft7 = FusionTensor(Float64, (g1,), (g2, g3, g4))
+  ft7 = FusionTensor{Float64}(undef, (g1,), (g2, g3, g4))
   @test_throws DimensionMismatch ft7 + ft3
   @test_throws DimensionMismatch ft7 - ft3
   @test_throws DimensionMismatch ft7 * ft3
@@ -309,6 +309,8 @@ end
     m = data_matrix(ft2)[Block(i, i)]
     @test m == 3 * LinearAlgebra.I(size(m, 1))
   end
+
+  @test FusionTensor{ComplexF64}(LinearAlgebra.I, (g1, g2)) isa FusionTensor{ComplexF64,4}
 end
 
 @testset "missing SectorProduct" begin
@@ -317,7 +319,7 @@ end
   g3 = gradedrange([SectorProduct(U1(1), SU2(1//2), Z{2}(1)) => 1])
   S = sector_type(g3)
 
-  ft = FusionTensor(Float64, (g1,), (dual(g2), dual(g3)))
+  ft = FusionTensor{Float64}(undef, (g1,), (dual(g2), dual(g3)))
   @test sector_type(ft) === S
   gr = gradedrange([SectorProduct(U1(1), SU2(0), Z{2}(0)) => 1])
   @test space_isequal(codomain_axis(ft), gr)
@@ -332,7 +334,7 @@ end
   gABC = tensor_product(gA, gB, gC)
   S = sector_type(gABC)
 
-  ft = FusionTensor(Float64, (gA, gB), (dual(gA), dual(gB), gC))
+  ft = FusionTensor{Float64}(undef, (gA, gB), (dual(gA), dual(gB), gC))
   @test sector_type(ft) === S
   @test space_isequal(codomain_axis(ft), gABC)
   @test space_isequal(domain_axis(ft), dual(gABC))