Runic formatter (#18)

* update formatter to runic

* update action

* change precompile statement

Author: lkdvos

.github/workflows/FormatCheck.yml

@@ -1,4 +1,4 @@
-name: "Format Check"
+name: FormatCheck
 
 on:
   push:
@@ -7,10 +7,11 @@ on:
       - 'master'
     tags: '*'
   pull_request:
+    branches:
+      - 'main'
+      - 'master'
 
 jobs:
-  format-check:
+  formatcheck:
     name: "Format Check"
-    uses: "QuantumKitHub/.github/.github/workflows/formatcheck.yml@main"
-    with: 
-      juliaformatter-version: "2"
+    uses: "QuantumKitHub/QuantumKitHubActions/.github/workflows/FormatCheck.yml@main"

src/TensorKitSectors.jl

@@ -10,7 +10,7 @@ export sectorscalartype
 export dim, sqrtdim, invsqrtdim, frobeniusschur, twist, fusiontensor, dual
 export otimes, deligneproduct, times
 export FusionStyle, UniqueFusion, MultipleFusion, SimpleFusion, GenericFusion,
-       MultiplicityFreeFusion
+    MultiplicityFreeFusion
 export BraidingStyle, NoBraiding, SymmetricBraiding, Bosonic, Fermionic, Anyonic
 export SectorSet, SectorValues, findindex
 export rightone, leftone
@@ -58,11 +58,14 @@ include("multifusion.jl") # multifusion example, namely Rep Z2 ⊕ Rep Z2 ≅ Is
 include("precompile.jl")
 
 function __precompile__()
-    for I in (Trivial, Z2Irrep, Z3Irrep, Z4Irrep, ZNIrrep, U1Irrep, SU2Irrep, CU1Irrep,
-              FermionParity, FermionNumber, FermionSpin, PlanarTrivial, FibonacciAnyon,
-              IsingAnyon, TimeReversed{IsingAnyon}, TimeReversed{FibonacciAnyon})
+    for I in (
+            Trivial, Z2Irrep, Z3Irrep, Z4Irrep, ZNIrrep, U1Irrep, SU2Irrep, CU1Irrep,
+            FermionParity, FermionNumber, FermionSpin, PlanarTrivial, FibonacciAnyon,
+            IsingAnyon, TimeReversed{IsingAnyon}, TimeReversed{FibonacciAnyon},
+        )
         precompile_sector(I)
     end
+    return
 end
 
 end # module TensorKitSectors

src/anyons.jl

@@ -13,10 +13,10 @@ struct PlanarTrivial <: Sector end
 
 Base.IteratorSize(::Type{SectorValues{PlanarTrivial}}) = HasLength()
 Base.length(::SectorValues{PlanarTrivial}) = 1
-Base.iterate(::SectorValues{PlanarTrivial}, i=0) = i == 0 ? (PlanarTrivial(), 1) : nothing
+Base.iterate(::SectorValues{PlanarTrivial}, i = 0) = i == 0 ? (PlanarTrivial(), 1) : nothing
 function Base.getindex(::SectorValues{PlanarTrivial}, i::Int)
     return i == 1 ? PlanarTrivial() :
-           throw(BoundsError(values(PlanarTrivial), i))
+        throw(BoundsError(values(PlanarTrivial), i))
 end
 findindex(::SectorValues{PlanarTrivial}, c::PlanarTrivial) = 1
 Base.isless(::PlanarTrivial, ::PlanarTrivial) = false
@@ -28,8 +28,8 @@ FusionStyle(::Type{PlanarTrivial}) = UniqueFusion()
 BraidingStyle(::Type{PlanarTrivial}) = NoBraiding()
 Base.isreal(::Type{PlanarTrivial}) = true
 
-Nsymbol(::Vararg{PlanarTrivial,3}) = 1
-Fsymbol(::Vararg{PlanarTrivial,6}) = 1
+Nsymbol(::Vararg{PlanarTrivial, 3}) = 1
+Fsymbol(::Vararg{PlanarTrivial, 6}) = 1
 
 ⊗(::PlanarTrivial, ::PlanarTrivial) = (PlanarTrivial(),)
 
@@ -56,7 +56,7 @@ end
 
 Base.IteratorSize(::Type{SectorValues{FibonacciAnyon}}) = HasLength()
 Base.length(::SectorValues{FibonacciAnyon}) = 2
-function Base.iterate(::SectorValues{FibonacciAnyon}, i=0)
+function Base.iterate(::SectorValues{FibonacciAnyon}, i = 0)
     return i == 0 ? (FibonacciAnyon(:I), 1) : (i == 1 ? (FibonacciAnyon(:τ), 2) : nothing)
 end
 function Base.getindex(S::SectorValues{FibonacciAnyon}, i::Int)
@@ -91,7 +91,7 @@ Base.IteratorSize(::Type{FibonacciIterator}) = Base.HasLength()
 Base.IteratorEltype(::Type{FibonacciIterator}) = Base.HasEltype()
 Base.length(iter::FibonacciIterator) = (isone(iter.a) || isone(iter.b)) ? 1 : 2
 Base.eltype(::Type{FibonacciIterator}) = FibonacciAnyon
-function Base.iterate(iter::FibonacciIterator, state=1)
+function Base.iterate(iter::FibonacciIterator, state = 1)
     I = FibonacciAnyon(:I)
     τ = FibonacciAnyon(:τ)
     if state == 1 # first iteration
@@ -110,8 +110,10 @@ function Nsymbol(a::FibonacciAnyon, b::FibonacciAnyon, c::FibonacciAnyon)
     return isone(a) + isone(b) + isone(c) != 2
 end # zero if one tau and two ones
 
-function Fsymbol(a::FibonacciAnyon, b::FibonacciAnyon, c::FibonacciAnyon,
-                 d::FibonacciAnyon, e::FibonacciAnyon, f::FibonacciAnyon)
+function Fsymbol(
+        a::FibonacciAnyon, b::FibonacciAnyon, c::FibonacciAnyon,
+        d::FibonacciAnyon, e::FibonacciAnyon, f::FibonacciAnyon
+    )
     Nsymbol(a, b, e) || return zero(_goldenratio)
     Nsymbol(e, c, d) || return zero(_goldenratio)
     Nsymbol(b, c, f) || return zero(_goldenratio)
@@ -144,7 +146,7 @@ end
 function Base.show(io::IO, a::FibonacciAnyon)
     s = isone(a) ? ":I" : ":τ"
     return get(io, :typeinfo, nothing) === FibonacciAnyon ?
-           print(io, s) : print(io, "FibonacciAnyon(", s, ")")
+        print(io, s) : print(io, "FibonacciAnyon(", s, ")")
 end
 
 Base.hash(a::FibonacciAnyon, h::UInt) = hash(a.isone, h)
@@ -179,7 +181,7 @@ const all_isinganyons = (IsingAnyon(:I), IsingAnyon(:σ), IsingAnyon(:ψ))
 
 Base.IteratorSize(::Type{SectorValues{IsingAnyon}}) = HasLength()
 Base.length(::SectorValues{IsingAnyon}) = length(all_isinganyons)
-Base.iterate(::SectorValues{IsingAnyon}, i=1) = iterate(all_isinganyons, i)
+Base.iterate(::SectorValues{IsingAnyon}, i = 1) = iterate(all_isinganyons, i)
 Base.getindex(::SectorValues{IsingAnyon}, i::Int) = getindex(all_isinganyons, i)
 
 function findindex(::SectorValues{IsingAnyon}, a::IsingAnyon)
@@ -214,7 +216,7 @@ function Base.length(iter::IsingIterator)
     return (iter.a == σ && iter.b == σ) ? 2 : 1
 end
 
-function Base.iterate(iter::IsingIterator, state=1)
+function Base.iterate(iter::IsingIterator, state = 1)
     I, σ, ψ = all_isinganyons
     if state == 1 # first iteration
         iter.a == I && return (iter.b, 2)
@@ -232,16 +234,20 @@ end
 
 function Nsymbol(a::IsingAnyon, b::IsingAnyon, c::IsingAnyon)
     I, σ, ψ = all_isinganyons
-    return ((a == I && b == c)
+    return (
+        (a == I && b == c)
             || (b == I && a == c)
             || (c == I && a == b)
             || (a == σ && b == σ && c == ψ)
             || (a == σ && b == ψ && c == σ)
-            || (a == ψ && b == σ && c == σ))
+            || (a == ψ && b == σ && c == σ)
+    )
 end
 
-function Fsymbol(a::IsingAnyon, b::IsingAnyon, c::IsingAnyon,
-                 d::IsingAnyon, e::IsingAnyon, f::IsingAnyon)
+function Fsymbol(
+        a::IsingAnyon, b::IsingAnyon, c::IsingAnyon,
+        d::IsingAnyon, e::IsingAnyon, f::IsingAnyon
+    )
     Nsymbol(a, b, e) || return 0.0
     Nsymbol(e, c, d) || return 0.0
     Nsymbol(b, c, f) || return 0.0

src/auxiliary.jl

@@ -31,7 +31,7 @@ end
 end
 
 @inline localoffset(d, I::Tuple{Int}, sz::Tuple{Int}) = 0
-@inline function localoffset(d, I::NTuple{N,Int}, sz::NTuple{N,Int}) where {N}
+@inline function localoffset(d, I::NTuple{N, Int}, sz::NTuple{N, Int}) where {N}
     offset = 0
     for i in 1:(I[1] - 1)
         offset += num_manhattan_points(d - i + 1, Base.tail(sz))
@@ -55,7 +55,7 @@ end
 
 # inverse mapping
 @inline invertlocaloffset(d, offset, sz::Tuple{Int}) = (d + 1,)
-@inline function invertlocaloffset(d, offset, sz::Tuple{Int,Int,Vararg{Int}})
+@inline function invertlocaloffset(d, offset, sz::Tuple{Int, Int, Vararg{Int}})
     i₁ = 1
     while i₁ < sz[1]
         jump = num_manhattan_points(d - i₁ + 1, Base.tail(sz))

src/fermions.jl

@@ -20,7 +20,7 @@ Base.convert(::Type{FermionParity}, a) = FermionParity(a)
 
 Base.IteratorSize(::Type{SectorValues{FermionParity}}) = HasLength()
 Base.length(::SectorValues{FermionParity}) = 2
-function Base.iterate(::SectorValues{FermionParity}, i=0)
+function Base.iterate(::SectorValues{FermionParity}, i = 0)
     return i == 2 ? nothing : (FermionParity(i), i + 1)
 end
 function Base.getindex(::SectorValues{FermionParity}, i::Int)
@@ -41,21 +41,21 @@ Base.isreal(::Type{FermionParity}) = true
 function Nsymbol(a::FermionParity, b::FermionParity, c::FermionParity)
     return (a.isodd ⊻ b.isodd) == c.isodd
 end
-function Fsymbol(a::I, b::I, c::I, d::I, e::I, f::I) where {I<:FermionParity}
+function Fsymbol(a::I, b::I, c::I, d::I, e::I, f::I) where {I <: FermionParity}
     return Int(Nsymbol(a, b, e) * Nsymbol(e, c, d) * Nsymbol(b, c, f) * Nsymbol(a, f, d))
 end
-function Rsymbol(a::I, b::I, c::I) where {I<:FermionParity}
+function Rsymbol(a::I, b::I, c::I) where {I <: FermionParity}
     return a.isodd && b.isodd ? -Int(Nsymbol(a, b, c)) : Int(Nsymbol(a, b, c))
 end
 twist(a::FermionParity) = a.isodd ? -1 : +1
 
-function fusiontensor(a::I, b::I, c::I) where {I<:FermionParity}
+function fusiontensor(a::I, b::I, c::I) where {I <: FermionParity}
     @warn "FermionParity Arrays do not preserve categorical properties." maxlog = 1
     return fill(Int(Nsymbol(a, b, c)), (1, 1, 1, 1))
 end
 
 function Base.show(io::IO, a::FermionParity)
-    if get(io, :typeinfo, nothing) === typeof(a)
+    return if get(io, :typeinfo, nothing) === typeof(a)
         print(io, Int(a.isodd))
     else
         print(io, type_repr(typeof(a)), "(", Int(a.isodd), ")")
@@ -97,7 +97,7 @@ See also: [`SU2Irrep`](@ref), [`FermionParity`](@ref)
 """
 const FermionSpin = SU2Irrep ⊠ FermionParity
 const fSU₂ = FermionSpin
-FermionSpin(j::Real) = (s=SU2Irrep(j); s ⊠ FermionParity(isodd(twice(s.j))))
+FermionSpin(j::Real) = (s = SU2Irrep(j); s ⊠ FermionParity(isodd(twice(s.j))))
 type_repr(::Type{FermionSpin}) = "FermionSpin"
 
 # convenience default converter -> allows Vect[FermionSpin](1 => 1)

src/groups.jl

@@ -21,7 +21,7 @@ type_repr(T::Type) = repr(T)
 
 const GroupTuple = Tuple{Vararg{Group}}
 
-abstract type ProductGroup{T<:GroupTuple} <: Group end
+abstract type ProductGroup{T <: GroupTuple} <: Group end
 
 """
     ×(G::Vararg{Type{<:Group}}) -> ProductGroup{Tuple{G...}}
@@ -34,20 +34,20 @@ const times = ×
 
 ×(a::Type{<:Group}, b::Type{<:Group}, c::Type{<:Group}...) = ×(×(a, b), c...)
 ×(G::Type{<:Group}) = ProductGroup{Tuple{G}}
-×(G1::Type{ProductGroup{Tuple{}}},
-G2::Type{ProductGroup{T}}) where {T<:GroupTuple} = G2
-function ×(G1::Type{ProductGroup{T1}},
-           G2::Type{ProductGroup{T2}}) where {T1<:GroupTuple,T2<:GroupTuple}
+×(G1::Type{ProductGroup{Tuple{}}}, G2::Type{ProductGroup{T}}) where {T <: GroupTuple} = G2
+function ×(
+        G1::Type{ProductGroup{T1}}, G2::Type{ProductGroup{T2}}
+    ) where {T1 <: GroupTuple, T2 <: GroupTuple}
     return tuple_type_head(T1) × (ProductGroup{tuple_type_tail(T1)} × G2)
 end
 ×(G1::Type{ProductGroup{Tuple{}}}, G2::Type{<:Group}) = ProductGroup{Tuple{G2}}
-function ×(G1::Type{ProductGroup{T}}, G2::Type{<:Group}) where {T<:GroupTuple}
+function ×(G1::Type{ProductGroup{T}}, G2::Type{<:Group}) where {T <: GroupTuple}
     return Base.tuple_type_head(T) × (ProductGroup{Base.tuple_type_tail(T)} × G2)
 end
-function ×(G1::Type{<:Group}, G2::Type{ProductGroup{T}}) where {T<:GroupTuple}
+function ×(G1::Type{<:Group}, G2::Type{ProductGroup{T}}) where {T <: GroupTuple}
     return ProductGroup{Base.tuple_type_cons(G1, T)}
 end
-×(G1::Type{<:Group}, G2::Type{<:Group}) = ProductGroup{Tuple{G1,G2}}
+×(G1::Type{<:Group}, G2::Type{<:Group}) = ProductGroup{Tuple{G1, G2}}
 
 function type_repr(G::Type{<:ProductGroup})
     T = G.parameters[1]