Turn edge count into a proper generically typed edge weight

Author: flowtoolz

Code/Graph+Algorithms/Graph+CondensationGraph.swift

@@ -43,8 +43,8 @@ public extension Graph
 
             if originSCC.id != destinationSCC.id
             {
-                condensationGraph.insert(.init(from: originSCC.id,
-                                               to: destinationSCC.id))
+                condensationGraph.insert(CondensationEdge(from: originSCC.id,
+                                                          to: destinationSCC.id))
             }
         }
 
@@ -55,7 +55,7 @@ public extension Graph
     typealias CondensationNode = CondensationGraph.Node
     typealias CondensationEdge = CondensationGraph.Edge
 
-    typealias CondensationGraph = Graph<StronglyConnectedComponent.ID, StronglyConnectedComponent>
+    typealias CondensationGraph = Graph<StronglyConnectedComponent.ID, StronglyConnectedComponent, EdgeWeight>
 
     struct StronglyConnectedComponent: Identifiable, Hashable
     {

Code/Graph+Algorithms/Graph+EssentialEdges.swift

@@ -7,7 +7,7 @@ public extension Graph
 
      Note that this will not remove any edges that are part of cycles (i.e. part of strongly connected components), since only considers edges of the condensation graph can be "non-essential". This is because it's [algorithmically](https://en.wikipedia.org/wiki/Feedback_arc_set#Hardness) as well as conceptually hard to decide which edges in cycles are "non-essential". We recommend dealing with cycles independently of using this function.
      */
-    func filteredEssentialEdges() -> Graph<NodeID, NodeValue>
+    func filteredEssentialEdges() -> Self
     {
         var result = self
         result.filterEssentialEdges()

Code/Graph+Algorithms/Graph+FilterAndMap.swift

@@ -2,15 +2,15 @@ public extension Graph
 {
     // MARK: - Value Mapper
 
-    func map<MappedValue>(_ transform: (NodeValue) throws -> MappedValue) rethrows -> Graph<NodeID, MappedValue>
+    func map<MappedValue>(_ transform: (NodeValue) throws -> MappedValue) rethrows -> Graph<NodeID, MappedValue, EdgeWeight>
     {
         .init(idValuePairs: try nodes.map { ($0.id, try transform($0.value)) },
               edges: edges)
     }
 
     // MARK: - Edge Filters
 
-    func filteredEdges(_ isIncluded: EdgeIDs) -> Graph<NodeID, NodeValue>
+    func filteredEdges(_ isIncluded: EdgeIDs) -> Self
     {
         var result = self
         result.filterEdges(isIncluded)
@@ -22,7 +22,7 @@ public extension Graph
         filterEdges { isIncluded.contains($0.id) }
     }
 
-    func filteredEdges(_ isIncluded: (Edge) throws -> Bool) rethrows -> Graph<NodeID, NodeValue>
+    func filteredEdges(_ isIncluded: (Edge) throws -> Bool) rethrows -> Self
     {
         var result = self
         try result.filterEdges(isIncluded)
@@ -42,7 +42,7 @@ public extension Graph
 
     // MARK: - Value Filters
 
-    func filtered(_ isIncluded: (NodeValue) throws -> Bool) rethrows -> Graph<NodeID, NodeValue>
+    func filtered(_ isIncluded: (NodeValue) throws -> Bool) rethrows -> Self
     {
         var result = self
         try result.filter(isIncluded)
@@ -56,7 +56,7 @@ public extension Graph
 
     // MARK: - Node Filters
 
-    func filteredNodes(_ isIncluded: NodeIDs) -> Graph<NodeID, NodeValue>
+    func filteredNodes(_ isIncluded: NodeIDs) -> Self
     {
         var result = self
         result.filterNodes(isIncluded)
@@ -68,7 +68,7 @@ public extension Graph
         filterNodes { isIncluded.contains($0.id) }
     }
 
-    func filteredNodes(_ isIncluded: (Node) throws -> Bool) rethrows -> Graph<NodeID, NodeValue>
+    func filteredNodes(_ isIncluded: (Node) throws -> Bool) rethrows -> Self
     {
         var result = self
         try result.filterNodes(isIncluded)

Code/Graph+Algorithms/Graph+TransitiveReduction.swift

@@ -7,7 +7,7 @@ public extension Graph
 
      🛑 This only works on acyclic graphs and might even hang or crash on cyclic ones!
      */
-    func filteredTransitiveReduction() -> Graph<NodeID, NodeValue>
+    func filteredTransitiveReduction() -> Self
     {
         var minimumEquivalentGraph = self
         minimumEquivalentGraph.filterTransitiveReduction()

Code/Graph+CreateAndAccess/Graph+EdgeAccess.swift

@@ -27,35 +27,35 @@ public extension Graph
     }
 
     /**
-     Add to the count of the edge with the given ID, create the edge if necessary
+     Add to weight of the edge with the given ID, create the edge if necessary
 
-     - Returns: The new count of the edge with the given ID
+     - Returns: The new weight of the edge with the given ID
      */
     @discardableResult
-    mutating func add(count: Int, toEdgeWith id: Edge.ID) -> Int
+    mutating func add(weight: EdgeWeight, toEdgeWith id: Edge.ID) -> EdgeWeight
     {
-        if let existingCount = edgesByID[id]?.count
+        if let existingWeight = edgesByID[id]?.weight
         {
-            edgesByID[id]?.count += count
+            edgesByID[id]?.weight += weight
 
-            return existingCount + count
+            return existingWeight + weight
         }
         else
         {
             insertEdge(from: id.originID,
                        to: id.destinationID,
-                       count: count)
+                       weight: weight)
 
-            return count
+            return weight
         }
     }
 
     @discardableResult
     mutating func insertEdge(from originID: NodeID,
                              to destinationID: NodeID,
-                             count: Int = 1) -> Edge
+                             weight: EdgeWeight = 1) -> Edge
     {
-        let edge = Edge(from: originID, to: destinationID, count: count)
+        let edge = Edge(from: originID, to: destinationID, weight: weight)
         insert(edge)
         return edge
     }

Code/Graph/Graph.swift

@@ -1,8 +1,11 @@
 import SwiftyToolz
 
-extension Graph: Sendable where NodeID: Sendable, NodeValue: Sendable {}
+public typealias HashableValuesGraph<Value: Hashable, EdgeWeight: Numeric> = Graph<Value, Value, EdgeWeight>
+public typealias IdentifiableValuesGraph<Value: Identifiable, EdgeWeight: Numeric> = Graph<Value.ID, Value, EdgeWeight>
+
+extension Graph: Sendable where NodeID: Sendable, NodeValue: Sendable, EdgeWeight: Sendable {}
 extension Graph: Equatable where NodeValue: Equatable {}
-extension Graph: Codable where NodeID: Codable, NodeValue: Codable {}
+extension Graph: Codable where NodeID: Codable, NodeValue: Codable, EdgeWeight: Codable {}
 
 /**
  Holds `Value`s in unique ``GraphNode``s which can be connected through ``GraphEdge``s
@@ -11,7 +14,7 @@ extension Graph: Codable where NodeID: Codable, NodeValue: Codable {}
 
  A `Graph` is Equatable if its `NodeValue` is. Equatability excludes the `determineNodeIDForNewValue` closure mentioned above.
  */
-public struct Graph<NodeID: Hashable, NodeValue>
+public struct Graph<NodeID: Hashable, NodeValue, EdgeWeight: Numeric>
 {
     // MARK: - Initialize
 
@@ -59,7 +62,7 @@ public struct Graph<NodeID: Hashable, NodeValue>
     /**
      Shorthand for the full generic type name `GraphEdge<NodeID>`
      */
-    public typealias Edge = GraphEdge<NodeID>
+    public typealias Edge = GraphEdge<NodeID, EdgeWeight>
 
     // MARK: - Nodes
 

Code/Graph/GraphEdge.swift

@@ -1,9 +1,9 @@
 import SwiftyToolz
 
-extension GraphEdge: Sendable where NodeID: Sendable {}
+extension GraphEdge: Sendable where NodeID: Sendable, Weight: Sendable {}
 extension GraphEdge.ID: Sendable where NodeID: Sendable {}
 
-extension GraphEdge: Codable where NodeID: Codable {}
+extension GraphEdge: Codable where NodeID: Codable, Weight: Codable {}
 extension GraphEdge.ID: Codable where NodeID: Codable {}
 
 /**
@@ -13,12 +13,12 @@ extension GraphEdge.ID: Codable where NodeID: Codable {}
 
  A `GraphEdge` is `Identifiable` by its ``GraphEdge/id-swift.property``, which is a combination of ``GraphEdge/originID`` and ``GraphEdge/destinationID``.
  */
-public struct GraphEdge<NodeID: Hashable>: Identifiable, Equatable
+public struct GraphEdge<NodeID: Hashable, Weight: Numeric>: Identifiable, Equatable
 {
     /**
      A shorthand for the edge's full generic type name `GraphEdge<NodeID>`
      */
-    public typealias Edge = GraphEdge<NodeID>
+    public typealias Edge = GraphEdge<NodeID, Weight>
 
     // MARK: - Identity
 
@@ -47,20 +47,20 @@ public struct GraphEdge<NodeID: Hashable>: Identifiable, Equatable
     /// Create a ``GraphEdge``, for instance to pass it to a ``Graph`` initializer.
     public init(from originID: NodeID,
                 to destinationID: NodeID,
-                count: Int = 1)
+                weight: Weight = 1)
     {
         self.originID = originID
         self.destinationID = destinationID
 
-        self.count = count
+        self.weight = weight
     }
 
     /**
-     A kind of edge weight. Indicates how often the edge was "added" to its graph.
+     The edge weight.
 
-     The count to "add" can be specified when adding an edge to a graph, see ``Graph/addEdge(from:to:count:)``. By default, adding the edge the first time sets its count to 1, and every time it gets added again adds 1 to its `count`.
+     If you don't need edge weights and want to save memory, you could specify `UInt8` (a.k.a. Byte) as the edge weight type, so each edge would require just one Byte instead of for example four or 8 Bytes for other numeric types.
      */
-    public internal(set) var count: Int
+    public internal(set) var weight: Weight
 
     /**
      The origin ``GraphNode/id`` at which the edge starts / from which it goes out

README.md

@@ -222,12 +222,11 @@ SwiftNodes is already being used in production, but [Codeface](https://codeface.
 
 1. Round out and add algorithms (starting with the needs of Codeface):
    1. Make existing algorithms compatible with cycles (two algorithms are still not). meaning: don't hang or crash, maybe throw an error!
-   2. Model edge weights so they *can* be considered in algorithms like Dijkstra. Do we really need a third type parameter for `Graph`? Or just use `Double` as universal weight type? Do we merge that with edge count or keep both distinct?
-   3. Update and complete documentation
-   4. Move to version 1.0.0 if possible
-   5. Add general purpose graph traversal algorithms (BFT, DFT, compatible with potentially cyclic graphs)
-   6. Add better ways of topological sorting
-   7. Approximate the [minimum feedback arc set](https://en.wikipedia.org/wiki/Feedback_arc_set), so Codeface can guess "faulty" or unintended dependencies, i.e. the fewest dependencies that need to be cut in order to break all cycles.
+   2. Update and complete documentation
+   3. Move to version 1.0.0 if possible
+   4. Add general purpose graph traversal algorithms (BFT, DFT, compatible with potentially cyclic graphs)
+   5. Add better ways of topological sorting
+   6. Approximate the [minimum feedback arc set](https://en.wikipedia.org/wiki/Feedback_arc_set), so Codeface can guess "faulty" or unintended dependencies, i.e. the fewest dependencies that need to be cut in order to break all cycles.
 2. Possibly optimize performance – but only based on measurements and only if measurements show that the optimization yields significant acceleration. Optimizing the algorithms might be more effective than optimizing the data structure itself.
     * What role does `@inlinable` play here?
     * What role does [`lazy`](https://developer.apple.com/documentation/swift/sequence/lazy) play here?

Tests/Algorithms/AncestorCountsTests.swift

@@ -4,44 +4,44 @@ import XCTest
 class AncestorCountsTests: XCTestCase {
 
     func testEmptyGraph() {
-        XCTAssertEqual(Graph<Int, Int>().findNumberOfNodeAncestors(),
+        XCTAssertEqual(TestGraph().findNumberOfNodeAncestors(),
                        [:])
     }
 
     func testGraphWithoutEdges() {
-        let graph = Graph(values: [1, 2, 3])
+        let graph = TestGraph(values: [1, 2, 3])
 
         XCTAssertEqual(graph.findNumberOfNodeAncestors(),
                        [1: 0, 2: 0, 3: 0])
     }
 
     func testGraphWithoutTransitiveEdges() {
-        let graph = Graph(values: [1, 2, 3],
-                          edges: [(1, 2), (2, 3)])
+        let graph = TestGraph(values: [1, 2, 3],
+                              edges: [(1, 2), (2, 3)])
 
         XCTAssertEqual(graph.findNumberOfNodeAncestors(),
                        [1: 0, 2: 1, 3: 2])
     }
 
     func testGraphWithOneTransitiveEdge() {
-        let graph = Graph(values: [1, 2, 3],
-                          edges: [(1, 2), (2, 3), (1, 3)])
+        let graph = TestGraph(values: [1, 2, 3],
+                              edges: [(1, 2), (2, 3), (1, 3)])
 
         XCTAssertEqual(graph.findNumberOfNodeAncestors(),
                        [1: 0, 2: 1, 3: 2])
     }
 
     func testGraphWithTwoComponentsEachWithOneTransitiveEdge() {
-        let graph = Graph(values: [1, 2, 3, 4, 5, 6],
-                          edges: [(1, 2), (2, 3), (1, 3), (4, 5), (5, 6), (4, 6)])
+        let graph = TestGraph(values: [1, 2, 3, 4, 5, 6],
+                              edges: [(1, 2), (2, 3), (1, 3), (4, 5), (5, 6), (4, 6)])
 
         XCTAssertEqual(graph.findNumberOfNodeAncestors(),
                        [1: 0, 2: 1, 3: 2, 4: 0, 5: 1, 6: 2])
     }
 
     func testGraphWithTwoSourcesAnd4PathsToSink() {
-        let graph = Graph(values: [0, 1, 2, 3, 4, 5],
-                          edges: [(0, 2), (1, 2), (2, 3), (2, 4), (3, 5), (4, 5)])
+        let graph = TestGraph(values: [0, 1, 2, 3, 4, 5],
+                              edges: [(0, 2), (1, 2), (2, 3), (2, 4), (3, 5), (4, 5)])
 
         XCTAssertEqual(graph.findNumberOfNodeAncestors(),
                        [0: 0, 1: 0, 2: 2, 3: 3, 4: 3, 5: 5])

Tests/Algorithms/ComponentTests.swift

@@ -4,37 +4,37 @@ import XCTest
 class ComponentTests: XCTestCase {
 
     func testEmptyGraph() {
-        XCTAssertEqual(Graph<Int, Int>().findComponents().count, 0)
+        XCTAssertEqual(TestGraph().findComponents().count, 0)
     }
 
     func testGraphWithoutEdges() {
-        let graph = Graph(values: [1, 2, 3])
+        let graph = TestGraph(values: [1, 2, 3])
 
         let expectedComponents: Set<Set<Int>> = [[1], [2], [3]]
 
         XCTAssertEqual(graph.findComponents(), expectedComponents)
     }
 
     func testGraphWithOneTrueComponent() {
-        let graph = Graph(values: [1, 2, 3], edges: [(1, 2), (2, 3)])
+        let graph = TestGraph(values: [1, 2, 3], edges: [(1, 2), (2, 3)])
 
         let expectedComponents: Set<Set<Int>> = [[1, 2, 3]]
 
         XCTAssertEqual(graph.findComponents(), expectedComponents)
     }
 
     func testGraphWithMultipleComponents() {
-        let graph = Graph(values: [1, 2, 3, 4, 5, 6],
-                          edges: [(2, 3), (4, 5), (5, 6)])
+        let graph = TestGraph(values: [1, 2, 3, 4, 5, 6],
+                              edges: [(2, 3), (4, 5), (5, 6)])
 
         let expectedComponents: Set<Set<Int>> = [[1], [2, 3], [4, 5, 6]]
 
         XCTAssertEqual(graph.findComponents(), expectedComponents)
     }
 
     func testGraphWithMultipleComponentsAndCycles() {
-        let graph = Graph(values: [1, 2, 3, 4, 5, 6],
-                          edges: [(2, 3), (3, 2), (4, 5), (5, 6), (6, 4)])
+        let graph = TestGraph(values: [1, 2, 3, 4, 5, 6],
+                              edges: [(2, 3), (3, 2), (4, 5), (5, 6), (6, 4)])
 
         let expectedComponents: Set<Set<Int>> = [[1], [2, 3], [4, 5, 6]]