Replace c == one(I) with isone(c) (#225)

This is a convenience change that should not alter the implementation,
but allows multifusion sectors to work better.
Taken from Boris' fork

Co-authored-by: Boris De Vos <[email protected]>

Author: lkdvos

src/fusiontrees/fusiontrees.jl

@@ -235,13 +235,13 @@ include("iterator.jl")
 # _abelianinner: generate the inner indices for given outer indices in the abelian case
 _abelianinner(outer::Tuple{}) = ()
 function _abelianinner(outer::Tuple{I}) where {I<:Sector}
-    return outer[1] == one(I) ? () : throw(SectorMismatch())
+    return isone(outer[1]) ? () : throw(SectorMismatch())
 end
 function _abelianinner(outer::Tuple{I,I}) where {I<:Sector}
     return outer[1] == dual(outer[2]) ? () : throw(SectorMismatch())
 end
 function _abelianinner(outer::Tuple{I,I,I}) where {I<:Sector}
-    return first(⊗(outer...)) == one(I) ? () : throw(SectorMismatch())
+    return isone(first(⊗(outer...))) ? () : throw(SectorMismatch())
 end
 function _abelianinner(outer::Tuple{I,I,I,I,Vararg{I}}) where {I<:Sector}
     c = first(outer[1] ⊗ outer[2])

src/fusiontrees/iterator.jl

@@ -37,7 +37,7 @@ Base.IteratorEltype(::FusionTreeIterator) = Base.HasEltype()
 Base.eltype(::Type{<:FusionTreeIterator{I,N}}) where {I<:Sector,N} = fusiontreetype(I, N)
 
 Base.length(iter::FusionTreeIterator) = _fusiondim(iter.uncouplediterators, iter.coupled)
-_fusiondim(::Tuple{}, c::I) where {I<:Sector} = Int(one(c) == c)
+_fusiondim(::Tuple{}, c::I) where {I<:Sector} = Int(isone(c))
 _fusiondim(iters::NTuple{1}, c::I) where {I<:Sector} = Int(c ∈ iters[1])
 function _fusiondim(iters::NTuple{2}, c::I) where {I<:Sector}
     d = 0
@@ -60,9 +60,9 @@ end
 # * Iterator methods:
 #   Start with special cases:
 function Base.iterate(it::FusionTreeIterator{I,0},
-                      state=(it.coupled != one(I))) where {I<:Sector}
+                      state=!isone(it.coupled)) where {I<:Sector}
     state && return nothing
-    tree = FusionTree{I}((), one(I), (), (), ())
+    tree = FusionTree{I}((), it.coupled, (), (), ())
     return tree, true
 end
 

src/fusiontrees/manipulations.jl

@@ -230,7 +230,7 @@ function merge(f₁::FusionTree{I,N₁}, f₂::FusionTree{I,N₂},
     return insertat(f, N₁ + 1, f₂)
 end
 function merge(f₁::FusionTree{I,0}, f₂::FusionTree{I,0}, c::I, μ) where {I}
-    c == one(I) ||
+    isone(c) ||
         throw(SectorMismatch("cannot fuse sectors $(f₁.coupled) and $(f₂.coupled) to $c"))
     return fusiontreedict(I)(f₁ => Fsymbol(c, c, c, c, c, c)[1, 1, 1, 1])
 end
@@ -349,7 +349,7 @@ function foldright(f₁::FusionTree{I,N₁}, f₂::FusionTree{I,N₂}) where {I<
             for μ in 1:Nsymbol(c1, c2, c)
                 fc = FusionTree((c1, c2), c, (!isduala, false), (), (μ,))
                 for (fl′, coeff1) in insertat(fc, 2, f₁)
-                    N₁ > 1 && fl′.innerlines[1] != one(I) && continue
+                    N₁ > 1 && !isone(fl′.innerlines[1]) && continue
                     coupled = fl′.coupled
                     uncoupled = Base.tail(Base.tail(fl′.uncoupled))
                     isdual = Base.tail(Base.tail(fl′.isdual))
@@ -694,7 +694,7 @@ corresponding coefficients.
 function elementary_trace(f::FusionTree{I,N}, i) where {I<:Sector,N}
     (N > 1 && 1 <= i <= N) ||
         throw(ArgumentError("Cannot trace outputs i=$i and i+1 out of only $N outputs"))
-    i < N || f.coupled == one(I) ||
+    i < N || isone(f.coupled) ||
         throw(ArgumentError("Cannot trace outputs i=$N and 1 of fusion tree that couples to non-trivial sector"))
 
     T = sectorscalartype(I)
@@ -808,15 +808,15 @@ function artin_braid(f::FusionTree{I,N}, i; inv::Bool=false) where {I<:Sector,N}
     inner = f.innerlines
     inner_extended = (uncoupled[1], inner..., coupled′)
     vertices = f.vertices
-    u = one(I)
     oneT = one(sectorscalartype(I))
 
-    if u in (uncoupled[i], uncoupled[i + 1])
+    if isone(uncoupled[i]) || isone(uncoupled[i + 1])
         # braiding with trivial sector: simple and always possible
         inner′ = inner
         vertices′ = vertices
         if i > 1 # we also need to alter innerlines and vertices
-            inner′ = TupleTools.setindex(inner, inner_extended[a == u ? (i + 1) : (i - 1)],
+            inner′ = TupleTools.setindex(inner,
+                                         inner_extended[isone(a) ? (i + 1) : (i - 1)],
                                          i - 1)
             vertices′ = TupleTools.setindex(vertices′, vertices[i], i - 1)
             vertices′ = TupleTools.setindex(vertices′, vertices[i - 1], i)