improve code quality

src/parameter.jl

@@ -1,4 +1,4 @@
-using .ZXW:Parameter, PiUnit, Factor
+using .ZXW: Parameter, PiUnit, Factor
 
 """
    Parameter

src/planar_multigraph.jl

@@ -122,68 +122,96 @@ function Base.:(==)(pmg1::PlanarMultigraph{T}, pmg2::PlanarMultigraph{T}) where
     return pmg_equiv(pmg1, pmg2, false)
 end
 
-function pmg_equiv(
-    pmg1::PlanarMultigraph{T},
-    pmg2::PlanarMultigraph{T},
-    verbose::Bool,
-) where {T<:Integer}
-    function print_nonoverlaping(dict1, dict2)
-        # Print elements in dict1 not in dict2
-        println("Elements in dict1 not in dict2:")
-        for (key, value) in dict1
-            if !haskey(dict2, key) || dict2[key] != value
-                println("Key: ", key, ", Value: ", value)
-            end
+"""
+    print_nonoverlaping(dict1, dict2)
+
+Helper function to print nonoverlaping elements in two dictionaries.
+"""
+function print_nonoverlaping(dict1, dict2)
+    # Print elements in dict1 not in dict2
+    println("Elements in dict1 not in dict2:")
+    for (key, value) in dict1
+        if !haskey(dict2, key) || dict2[key] != value
+            println("Key: ", key, ", Value: ", value)
         end
+    end
 
-        println()
+    println()
 
-        # Print elements in dict2 not in dict1
-        println("Elements in dict2 not in dict1:")
-        for (key, value) in dict2
-            if !haskey(dict1, key) || dict1[key] != value
-                println("Key: ", key, ", Value: ", value)
-            end
+    # Print elements in dict2 not in dict1
+    println("Elements in dict2 not in dict1:")
+    for (key, value) in dict2
+        if !haskey(dict1, key) || dict1[key] != value
+            println("Key: ", key, ", Value: ", value)
         end
+    end
+
+end
+
+"""
+    equiv_v2he(pmg1::PlanarMultigraph, pmg2::PlanarMultigraph)
 
+Checking if the vertex to half edge mapping is equivalent.
+"""
+function equiv_v2he(pmg1::PlanarMultigraph, pmg2::PlanarMultigraph)
+    if length(keys(pmg1.v2he)) != length(keys(pmg2.v2he))
+        return false
     end
-    function equiv_v2he(pmg1::PlanarMultigraph, pmg2::PlanarMultigraph)
-        if length(keys(pmg1.v2he)) != length(keys(pmg2.v2he))
+
+    for (v, _) in pmg1.v2he
+        if !haskey(pmg2.v2he, v)
             return false
         end
-
-        for (v, _) in pmg1.v2he
-            if !haskey(pmg2.v2he, v)
-                return false
-            end
-            if pmg2.v2he[v] ∉ trace_vertex(pmg1, v)
-                return false
-            end
+        if pmg2.v2he[v] ∉ trace_vertex(pmg1, v)
+            return false
         end
-        return true
     end
-    if !equiv_v2he(pmg1, pmg2)
-        if verbose
-            println("v2he")
-            print_nonoverlaping(pmg1.v2he, pmg2.v2he)
-        end
+    return true
+end
+
+"""
+    equiv_f2he(pmg1::PlanarMultigraph, pmg2::PlanarMultigraph)
+
+Checking if the face to half edge mapping is equivalent.
+"""
+function equiv_f2he(pmg1::PlanarMultigraph, pmg2::PlanarMultigraph)
+    if length(keys(pmg1.f2he)) != length(keys(pmg2.f2he))
         return false
     end
 
-    function equiv_f2he(pmg1::PlanarMultigraph, pmg2::PlanarMultigraph)
-        if length(keys(pmg1.f2he)) != length(keys(pmg2.f2he))
+    for (f_id, _) in pmg1.f2he
+        if !haskey(pmg2.f2he, f_id)
             return false
         end
+        if pmg2.f2he[f_id] ∉ trace_face(pmg1, f_id)
+            return false
+        end
+    end
+    return true
+end
+
+"""
+    pmg_equiv(
+    pmg1::PlanarMultigraph{T},
+    pmg2::PlanarMultigraph{T},
+    verbose::Bool,
+) where {T<:Integer}
+
+Checking if two PlanarMultigraphs are equivalent.
 
-        for (f_id, _) in pmg1.f2he
-            if !haskey(pmg2.f2he, f_id)
-                return false
-            end
-            if pmg2.f2he[f_id] ∉ trace_face(pmg1, f_id)
-                return false
-            end
+If verbose is true, then print out the nonoverlaping elements in the two.
+"""
+function pmg_equiv(
+    pmg1::PlanarMultigraph{T},
+    pmg2::PlanarMultigraph{T},
+    verbose::Bool,
+) where {T<:Integer}
+    if !equiv_v2he(pmg1, pmg2)
+        if verbose
+            println("v2he")
+            print_nonoverlaping(pmg1.v2he, pmg2.v2he)
         end
-        return true
+        return false
     end
 
     if !equiv_f2he(pmg1, pmg2)

src/zw_diagram.jl

@@ -42,16 +42,23 @@ end
 ZWDiagram(
     pmg::PlanarMultigraph{T},
     st::Dict{T,ZWSpiderType},
-    P::Type = Rational,
-) where {T} = ZWDiagram{T,P}(pmg, st)
+    scalar::Scalar{P},
+) where {T,P} = ZWDiagram{T,P}(pmg, st, scalar)
 
 ZWDiagram(
     pmg::PlanarMultigraph{T},
     st::Vector{ZWSpiderType},
-    P::Type = Rational,
-) where {T} = ZWDiagram{T,P}(pmg, Dict(zip(sort!(vertices(pmg)), st)))
+    scalar::Scalar{P},
+) where {T,P} = ZWDiagram{T,P}(pmg, Dict(zip(sort!(vertices(pmg)), st)), scalar)
 
-function ZWDiagram(nbits::T) where {T<:Integer}
+"""
+    ZWDiagram(::Type{P}, nbits::T) where {T<:Integer}
+
+Create a ZW-diagram with `nbits` input and output qubits.
+
+Scalar is parameterized to be `P`.
+"""
+function ZWDiagram(nbits::T, ::Type{P} = Rational) where {T<:Integer,P}
     nbits < 1 && error("We need to have at least one qubit in the system!")
 
     half_edges = Dict{T,HalfEdge}()
@@ -172,7 +179,7 @@ function ZWDiagram(nbits::T) where {T<:Integer}
 
     st = [i % 2 == 1 ? Input(div(i, 2) + 1) : Output(div(i, 2)) for i = 1:2*nbits]
 
-    return ZWDiagram(pmg, st)
+    return ZWDiagram(pmg, st, Scalar{P}())
 end
 
 Base.copy(zwd::ZWDiagram{T,P}) where {T,P} = ZWDiagram{T,P}(

src/zw_utils.jl

@@ -38,7 +38,7 @@ function parameter(zwd::ZWDiagram{T,P}, v::T) where {T<:Integer,P}
         binZ(p) => p
         monoZ(p) => p
         Input(q) || Output(q) => q
-        _ => Parameter(Val(:PiUnit), 0)
+        _ => nothing
     end
 end
 
@@ -181,7 +181,7 @@ end
     add_spider!(zwd, spider, connect = [])
 
 Add a new spider `spider` with appropriate parameter
-connected to the half edges`connect`.
+connected to the half edges `connect`.
 
 Had to make halfedge class 1 citizen because there will be ambiguity
 Consider A to B and there are multiple edges to A and from A to B

test/zw_diagram.jl

@@ -19,8 +19,9 @@ using ZXCalculus.ZW: ZWDiagram, Input, Output
     @test zx1.inputs == [1]
     @test zx1.outputs == [2]
     @test zx1.pmg == pmg1
+    @test zx1.scalar == Scalar{Rational}()
 
-    zx2 = ZWDiagram(2)
+    zx2 = ZWDiagram(2, Float64)
     pmg2 = PlanarMultigraph(
         Dict([1 => 1, 2 => 2, 3 => 3, 4 => 4]),
         Dict([
@@ -48,6 +49,7 @@ using ZXCalculus.ZW: ZWDiagram, Input, Output
     @test zx2.outputs == [2, 4]
     @test zx2.pmg == pmg2
     @test zx2.pmg.half_edges == pmg2.half_edges
+    @test zx2.scalar == Scalar{Float64}()
 
     zx3 = ZWDiagram(3)