fix to_fusiontensor name

Author: ogauthe

src/fusiontensor/array_cast.jl

@@ -10,13 +10,6 @@ using TensorAlgebra: contract
 # =================================  High level interface  =================================
 
 #### cast from array to symmetric
-function to_fusiontensor(
-  array::AbstractArray,
-  codomain_legs::Tuple{Vararg{AbstractGradedUnitRange}},
-  domain_legs::Tuple{Vararg{AbstractGradedUnitRange}},
-)
-  return to_fusiontensor(array, codomain_legs, domain_legs)
-end
 
 #### cast from symmetric to array
 function BlockSparseArrays.BlockSparseArray(ft::FusionTensor)

src/fusiontensor/base_interface.jl

@@ -13,7 +13,7 @@ Base.:*(ft::FusionTensor, x::Number) = x * ft
 function Base.:*(left::FusionTensor, right::FusionTensor)
   checkaxes_dual(domain_axes(left), codomain_axes(right))
   new_data_matrix = data_matrix(left) * data_matrix(right)
-  return to_fusiontensor(new_data_matrix, codomain_axes(left), domain_axes(right))
+  return FusionTensor(new_data_matrix, codomain_axes(left), domain_axes(right))
 end
 
 Base.:+(ft::FusionTensor) = ft

src/fusiontensor/fusiontensor.jl

@@ -81,6 +81,7 @@ function BlockArrays.findblock(ft::FusionTensor, f1::SectorFusionTree, f2::Secto
   b2 = find_sector_block.(leaves(f2), dual.(domain_axes(ft)))
   return Block(b1..., b2...)
 end
+# TBD move to GradedUnitRanges? rename findfirst_sector?
 function find_sector_block(s::AbstractSector, l::AbstractGradedUnitRange)
   return findfirst(==(s), blocklabels(l))
 end

src/permutedims/permutedims.jl

@@ -12,7 +12,7 @@ function naive_permutedims(ft, biperm::BlockedPermutation{2})
   # naive permute: cast to dense, permutedims, cast to FusionTensor
   arr = Array(ft)
   permuted_arr = permutedims(arr, Tuple(biperm))
-  permuted = FusionTensor(permuted_arr, new_codomain_legs, new_domain_legs)
+  permuted = to_fusiontensor(permuted_arr, new_codomain_legs, new_domain_legs)
   return permuted
 end
 

test/basics/test_basics.jl

@@ -6,7 +6,7 @@ using FusionTensors:
   codomain_axes,
   data_matrix,
   domain_axes,
-  fusiontensor,
+  FusionTensor,
   checkaxes,
   checkaxes_dual,
   matrix_column_axis,
@@ -30,7 +30,7 @@ include("setup.jl")
   @test space_isequal(matrix_column_axis(ft0), g2)
 
   m = BlockSparseArray{Float64}(g1, g2)
-  ft1 = fusiontensor(m, (g1,), (g2,))
+  ft1 = FusionTensor(m, (g1,), (g2,))
 
   # getters
   @test data_matrix(ft1) == m
@@ -100,7 +100,7 @@ end
   gr = fusion_product(g1, g2)
   gc = dual(fusion_product(dual(g3), dual(g4)))
   m2 = BlockSparseArray{Float64}(gr, gc)
-  ft = fusiontensor(m2, (g1, g2), (g3, g4))
+  ft = FusionTensor(m2, (g1, g2), (g3, g4))
 
   @test data_matrix(ft) == m2
   @test checkaxes(codomain_axes(ft), (g1, g2))

test/basics/test_linear_algebra.jl

@@ -5,7 +5,7 @@ using Test: @test, @testset
 using BlockArrays: BlockArrays
 
 using BlockSparseArrays: BlockSparseArrays
-using FusionTensors: FusionTensor
+using FusionTensors: FusionTensor, to_fusiontensor
 using GradedUnitRanges: dual, gradedrange
 using SymmetrySectors: U1, SU2, TrivialSector
 
@@ -30,7 +30,7 @@ include("setup.jl")
     @test norm(ft0) == 0
     @test tr(ft0) == 0
 
-    ft = FusionTensor(sdst, (g, g), (dual(g), dual(g)))
+    ft = to_fusiontensor(sdst, (g, g), (dual(g), dual(g)))
     @test isnothing(check_sanity(ft))
     @test norm(ft) ≈ √3 / 2
     @test isapprox(tr(ft), 0; atol=eps(Float64))

test/basics/test_permutedims.jl

@@ -9,7 +9,8 @@ using FusionTensors:
   matrix_row_axis,
   naive_permutedims,
   ndims_domain,
-  ndims_codomain
+  ndims_codomain,
+  to_fusiontensor
 using GradedUnitRanges: dual, gradedrange, space_isequal
 using SymmetrySectors: O2, U1, SectorProduct, SU2
 using TensorAlgebra: blockedperm
@@ -67,7 +68,7 @@ include("setup.jl")
     arr[3:4, 1:3, 5:5, 1:2] .= 2.0
     arr[1:2, 4:5, 5:5, 1:2] .= 3.0
     arr[3:4, 4:5, 1:4, 3:3] .= 4.0
-    ft = FusionTensor(arr, codomain_legs, domain_legs)
+    ft = to_fusiontensor(arr, codomain_legs, domain_legs)
     biperm = blockedperm((3,), (2, 4, 1))
 
     ftp = permutedims(ft, biperm)
@@ -85,7 +86,7 @@ include("setup.jl")
 
   @testset "Less than two axes" begin
     if VERSION >= v"1.11"
-      @test_broken FusionTensor(ones(()), (), ()) isa FusionTensor
+      @test_broken to_fusiontensor(ones(()), (), ()) isa FusionTensor
       #=  ft0p = permutedims(ft0, (), ())
         @test ft0p isa FusionTensor{Float64,0}
         @test data_matrix(ft0p) ≈ data_matrix(ft0)
@@ -100,7 +101,7 @@ include("setup.jl")
     v = zeros((6,))
     v[1] = 1.0
     biperm = blockedperm((), (1,))
-    ft1 = FusionTensor(v, (g,), ())
+    ft1 = to_fusiontensor(v, (g,), ())
     ft2 = permutedims(ft1, biperm)
     @test isnothing(check_sanity(ft2))
     @test ft2 ≈ naive_permutedims(ft1, biperm)
@@ -142,16 +143,16 @@ end
     for biperm in [
       blockedperm((2, 1), (3, 4)), blockedperm((3, 1), (2, 4)), blockedperm((3, 1, 4), (2,))
     ]
-      ft = FusionTensor(sds22, (g2, g2), (g2b, g2b))
+      ft = to_fusiontensor(sds22, (g2, g2), (g2b, g2b))
       @test permutedims(ft, biperm) ≈ naive_permutedims(ft, biperm)
       @test permutedims(adjoint(ft), biperm) ≈ naive_permutedims(adjoint(ft), biperm)
 
-      ft = FusionTensor(sds22b, (g2, g2b), (g2b, g2))
+      ft = to_fusiontensor(sds22b, (g2, g2b), (g2b, g2))
       @test permutedims(ft, biperm) ≈ naive_permutedims(ft, biperm)
       @test permutedims(adjoint(ft), biperm) ≈ naive_permutedims(adjoint(ft), biperm)
     end
     for biperm in [blockedperm((1, 2, 3, 4), ()), blockedperm((), (3, 1, 2, 4))]
-      ft = FusionTensor(sds22, (g2, g2), (g2b, g2b))
+      ft = to_fusiontensor(sds22, (g2, g2), (g2b, g2b))
       @test permutedims(ft, biperm) ≈ naive_permutedims(ft, biperm)
     end
   end