Rename IsingBimod to IsingBimodule (#17)

* rename `IsingBimod` to `IsingBimodule`

* Bump v0.2.0

* Fix typo

* small fix

* format

Author: lkdvos

Project.toml

@@ -1,7 +1,7 @@
 name = "TensorKitSectors"
 uuid = "13a9c161-d5da-41f0-bcbd-e1a08ae0647f"
 authors = ["Lukas Devos", "Jutho Haegeman"]
-version = "0.1.7"
+version = "0.2.0"
 
 [deps]
 HalfIntegers = "f0d1745a-41c9-11e9-1dd9-e5d34d218721"

src/TensorKitSectors.jl

@@ -21,7 +21,7 @@ export Trivial, Z2Irrep, Z3Irrep, Z4Irrep, ZNIrrep, U1Irrep, SU2Irrep, CU1Irrep
 export ProductSector, TimeReversed
 export FermionParity, FermionNumber, FermionSpin
 export PlanarTrivial, FibonacciAnyon, IsingAnyon
-export IsingBimod
+export IsingBimodule
 
 # unicode exports
 # ---------------

src/multifusion.jl

@@ -3,100 +3,102 @@
 # this is mainly meant for testing within TensorKit without relying on MultiTensorKit
 #------------------------------------------------------------------------------#
 
-# 𝒞   ℳ 
+# 𝒞   ℳ
 # ℳᵒᵖ 𝒟
-struct IsingBimod <: Sector
+struct IsingBimodule <: Sector
     row::Int
     col::Int
     label::Int
-    function IsingBimod(row::Int, col::Int, label::Int)
+    function IsingBimodule(row::Int, col::Int, label::Int)
         1 <= row <= 2 && 1 <= col <= 2 ||
             throw(DomainError(lazy"Invalid subcategory ($row, $col)"))
         0 <= label <= (row == col) ||
-            throw(ArgumentError(lazy"Invalid label $label for IsingBimod subcategory ($row, $col)"))
+            throw(ArgumentError(lazy"Invalid label $label for IsingBimodule subcategory ($row, $col)"))
         return new(row, col, label)
     end
 end
 
-const all_isingbimod_objects = (IsingBimod(1, 1, 0), IsingBimod(1, 1, 1),
-                                IsingBimod(2, 1, 0), IsingBimod(1, 2, 0),
-                                IsingBimod(2, 2, 0), IsingBimod(2, 2, 1))
+const all_isingbimod_objects = (IsingBimodule(1, 1, 0), IsingBimodule(1, 1, 1),
+                                IsingBimodule(2, 1, 0), IsingBimodule(1, 2, 0),
+                                IsingBimodule(2, 2, 0), IsingBimodule(2, 2, 1))
 
-Base.IteratorSize(::Type{SectorValues{IsingBimod}}) = Base.SizeUnknown()
-Base.iterate(::SectorValues{IsingBimod}, i=1) = iterate(all_isingbimod_objects, i)
-Base.length(::SectorValues{IsingBimod}) = length(all_isingbimod_objects)
+Base.IteratorSize(::Type{SectorValues{IsingBimodule}}) = Base.SizeUnknown()
+Base.iterate(::SectorValues{IsingBimodule}, i=1) = iterate(all_isingbimod_objects, i)
+Base.length(::SectorValues{IsingBimodule}) = length(all_isingbimod_objects)
 
-⊗(a::IsingBimod, b::IsingBimod) = IsingBimodIterator(a, b)
+⊗(a::IsingBimodule, b::IsingBimodule) = IsingBimoduleIterator(a, b)
 
-struct IsingBimodIterator
-    a::IsingBimod
-    b::IsingBimod
+struct IsingBimoduleIterator
+    a::IsingBimodule
+    b::IsingBimodule
 end
 
-Base.IteratorSize(::Type{IsingBimodIterator}) = Base.SizeUnknown()
-Base.IteratorEltype(::Type{IsingBimodIterator}) = Base.HasEltype()
-Base.eltype(::Type{IsingBimodIterator}) = IsingBimod
+Base.IteratorSize(::Type{IsingBimoduleIterator}) = Base.SizeUnknown()
+Base.IteratorEltype(::Type{IsingBimoduleIterator}) = Base.HasEltype()
+Base.eltype(::Type{IsingBimoduleIterator}) = IsingBimodule
 
-function Base.iterate(iter::IsingBimodIterator, state=0)
+function Base.iterate(iter::IsingBimoduleIterator, state=0)
     a, b = iter.a, iter.b
     a.col == b.row || return nothing
 
     _state = (a.row == b.col == a.col) ? mod(a.label + b.label, 2) : state
     return state < (1 + (a.row == b.col && a.row != a.col)) ?
-           (IsingBimod(a.row, b.col, _state), state + 1) : nothing
+           (IsingBimodule(a.row, b.col, _state), state + 1) : nothing
 end
 
-Base.convert(::Type{IsingBimod}, labels::NTuple{3,Int}) = IsingBimod(labels...)
+Base.convert(::Type{IsingBimodule}, labels::NTuple{3,Int}) = IsingBimodule(labels...)
 
-function Base.convert(::Type{IsingAnyon}, a::IsingBimod) # identify RepZ2 ⊕ RepZ2 ≅ Ising
+function Base.convert(::Type{IsingAnyon}, a::IsingBimodule) # identify RepZ2 ⊕ RepZ2 ≅ Ising
     (a.row != a.col) && return IsingAnyon(:σ)
     return IsingAnyon(a.label == 0 ? :I : :ψ)
 end
 
-FusionStyle(::Type{IsingBimod}) = SimpleFusion() # no multiplicities
-BraidingStyle(::Type{IsingBimod}) = NoBraiding() # because of module categories
+FusionStyle(::Type{IsingBimodule}) = SimpleFusion() # no multiplicities
+BraidingStyle(::Type{IsingBimodule}) = NoBraiding() # because of module categories
 
-function Nsymbol(a::IsingBimod, b::IsingBimod, c::IsingBimod)
+function Nsymbol(a::IsingBimodule, b::IsingBimodule, c::IsingBimodule)
     if (a.row != c.row) || (a.col != b.row) || (b.col != c.col)
         throw(ArgumentError("invalid fusion channel"))
     end
     return Nsymbol(convert(IsingAnyon, a), convert(IsingAnyon, b), convert(IsingAnyon, c))
 end
 
-function Fsymbol(a::I, b::I, c::I, d::I, e::I, f::I) where {I<:IsingBimod}
+function Fsymbol(a::I, b::I, c::I, d::I, e::I, f::I) where {I<:IsingBimodule}
     Nsymbol(a, b, e) && Nsymbol(e, c, d) &&
     Nsymbol(b, c, f) && Nsymbol(a, f, d) || return 0.0
     return Fsymbol(convert(IsingAnyon, a), convert(IsingAnyon, b), convert(IsingAnyon, c),
                    convert(IsingAnyon, d), convert(IsingAnyon, e), convert(IsingAnyon, f))
 end
 
 # ℳ ↔ ℳop when conjugating elements within these
-Base.conj(a::IsingBimod) = IsingBimod(a.col, a.row, a.label)
+Base.conj(a::IsingBimodule) = IsingBimodule(a.col, a.row, a.label)
 
-rightone(a::IsingBimod) = IsingBimod(a.col, a.col, 0)
-leftone(a::IsingBimod) = IsingBimod(a.row, a.row, 0)
+rightone(a::IsingBimodule) = IsingBimodule(a.col, a.col, 0)
+leftone(a::IsingBimodule) = IsingBimodule(a.row, a.row, 0)
 
-function Base.one(a::IsingBimod)
+function Base.one(a::IsingBimodule)
     a.row == a.col ||
         throw(DomainError("unit of module category ($(a.row), $(a.col)) doesn't exist"))
-    return IsingBimod(a.row, a.col, 0)
+    return IsingBimodule(a.row, a.col, 0)
 end
 
-Base.one(::Type{IsingBimod}) = throw(ArgumentError("one of Type IsingBimod doesn't exist"))
+function Base.one(::Type{IsingBimodule})
+    throw(ArgumentError("one of Type IsingBimodule doesn't exist"))
+end
 
-function Base.isless(a::IsingBimod, b::IsingBimod)
+function Base.isless(a::IsingBimodule, b::IsingBimodule)
     return isless((a.col, a.row, a.label), (b.col, b.row, b.label))
 end
 
-function Base.hash(a::IsingBimod, h::UInt)
+function Base.hash(a::IsingBimodule, h::UInt)
     return hash(a.label, hash(a.row, hash(a.col, h)))
 end
 
-function Base.show(io::IO, a::IsingBimod)
-    if get(io, :typeinfo, nothing) === IsingBimod
+function Base.show(io::IO, a::IsingBimodule)
+    if get(io, :typeinfo, nothing) === IsingBimodule
         print(io, (a.row, a.col, a.label))
     else
-        print(io, "IsingBimod", (a.row, a.col, a.label))
+        print(io, "IsingBimodule", (a.row, a.col, a.label))
     end
     return nothing
 end

test/multifusion.jl

@@ -1,17 +1,17 @@
-I = IsingBimod
+I = IsingBimodule
 Istr = TensorKitSectors.type_repr(I)
 @testset "$Istr sector" begin
     @testset "Basic type properties" begin
         @test eval(Meta.parse(sprint(show, I))) == I
         @test eval(Meta.parse(TensorKitSectors.type_repr(I))) == I
     end
 
-    M = IsingBimod(1, 2, 0)
-    Mop = IsingBimod(2, 1, 0)
-    C0 = IsingBimod(1, 1, 0)
-    C1 = IsingBimod(1, 1, 1)
-    D0 = IsingBimod(2, 2, 0)
-    D1 = IsingBimod(2, 2, 1)
+    M = IsingBimodule(1, 2, 0)
+    Mop = IsingBimodule(2, 1, 0)
+    C0 = IsingBimodule(1, 1, 0)
+    C1 = IsingBimodule(1, 1, 1)
+    D0 = IsingBimodule(2, 2, 0)
+    D1 = IsingBimodule(2, 2, 1)
     C = rand([C0, C1])
     D = rand([D0, D1])
     s = rand((M, Mop, C, D))