digraphx 0.3__tar.gz → 0.4__tar.gz

{digraphx-0.3 → digraphx-0.4}/.github/workflows/ci.bak

@@ -8,7 +8,7 @@ on:
   push:
     # Avoid using all the resources/limits available by checking only
     # relevant branches and tags. Other branches can be checked via PRs.
-    branches: [main]
+    branches: [ main, dev ]
     tags: ['v[0-9]*', '[0-9]+.[0-9]+*']  # Match tags that resemble a version
   pull_request:  # Run in every PR
   workflow_dispatch:  # Allow manually triggering the workflow

{digraphx-0.3 → digraphx-0.4}/.github/workflows/python-app.yml

@@ -5,9 +5,9 @@ name: Python application
 
 on:
   push:
-    branches: [main]
+    branches: [ main, dev ]
   pull_request:
-    branches: [main]
+    branches: [ main, dev ]
 
 jobs:
   build:

{digraphx-0.3/src/digraphx.egg-info → digraphx-0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digraphx
-Version: 0.3
+Version: 0.4
 Summary: Network Optimization Python Code
 Home-page: https://github.com/luk036/digraphx
 Author: Wai-Shing Luk

{digraphx-0.3 → digraphx-0.4}/src/digraphx/neg_cycle.py

@@ -42,11 +42,14 @@ useful in many different applications.
 """
 
 from fractions import Fraction
+from math import floor
 from typing import (
+    Any,
     Callable,
     Dict,
     Generator,
     Generic,
+    Iterable,
     List,
     Mapping,
     MutableMapping,
@@ -62,6 +65,30 @@ Domain = TypeVar(
 )  # Numeric type for weights (must support comparison and arithmetic)
 Cycle = List[Arc]  # Alias for a list of edges forming a cycle
 
+# NOTE: get_weight return type is `Any` (not `Domain`) to match C++ template
+# semantics where the Callable return type is independent from the dist value
+# type (Mapping). C++ `digraphx-cpp` uses unconstrained template parameters:
+#
+#   template <typename Mapping, typename Callable>
+#   auto howard(Mapping& dist, Callable get_weight);
+#
+# The `Domain` TypeVar only constrains dist values; get_weight may return a
+# different numeric type (e.g., float weight with int dist). When dist[u] is
+# int and the sum is float, int(floor(...)) truncates like C++ implicit
+# double→int conversion on assignment.
+
+
+def _view_items(container: Iterable[Tuple[Node, Arc]]) -> Iterable[Tuple[Node, Arc]]:
+    """Get a pair-iterable view of a neighbor container.
+
+    Mirrors C++ `_view_items` in digraphx-cpp/neg_cycle.hpp:
+    - For dict-like containers, use .items() to get (key, value) pairs
+    - For list-like containers, iterate directly (each element is a pair)
+    """
+    if isinstance(container, dict):
+        return container.items()
+    return container
+
 
 class NegCycleFinder(Generic[Node, Arc, Domain]):
     """Negative Cycle Finder by Howard's method
@@ -105,14 +132,14 @@ class NegCycleFinder(Generic[Node, Arc, Domain]):
     # Dictionary to store predecessor information (node -> (predecessor_node, edge))
     pred: Dict[Node, Tuple[Node, Arc]]
 
-    def __init__(self, digraph: Mapping[Node, Mapping[Node, Arc]]) -> None:
+    def __init__(self, digraph: Mapping[Node, Iterable[Tuple[Node, Arc]]]) -> None:
         """Initialize the negative cycle finder with a directed graph.
 
         Args:
             digraph: A mapping representing a directed graph where:
                 - Keys are source nodes
-                - Values are mappings of destination nodes to edges
-                Example: {u: {v: edge_uv, w: edge_uw}, v: {u: edge_vu}}
+                - Values are iterables of (target_node, edge) pairs
+                Example: {u: [(v, edge_uv), (w, edge_uw)], v: [(u, edge_vu)]}
         """
         self.digraph = digraph
         self.pred: Dict[Node, Tuple[Node, Arc]] = {}
@@ -155,7 +182,7 @@ class NegCycleFinder(Generic[Node, Arc, Domain]):
     def relax(
         self,
         dist: MutableMapping[Node, Domain],
-        get_weight: Callable[[Arc], Domain],
+        get_weight: Callable[[Arc], Any],
     ) -> bool:
         """Perform one relaxation pass of the Bellman-Ford algorithm.
 
@@ -189,8 +216,11 @@ class NegCycleFinder(Generic[Node, Arc, Domain]):
         """
         changed = False
         for u_node, neighbors in self.digraph.items():
-            for v_node, edge in neighbors.items():
-                distance = dist[u_node] + get_weight(edge)
+            for v_node, edge in _view_items(neighbors):
+                tmp = dist[u_node] + get_weight(edge)
+                if isinstance(dist[u_node], int) and isinstance(tmp, float):
+                    tmp = int(floor(tmp))
+                distance = tmp
                 if dist[v_node] > distance:  # Found a shorter path
                     dist[v_node] = distance
                     self.pred[v_node] = (u_node, edge)  # Update predecessor
@@ -234,7 +264,7 @@ class NegCycleFinder(Generic[Node, Arc, Domain]):
         self,
         handle: Node,
         dist: MutableMapping[Node, Domain],
-        get_weight: Callable[[Arc], Domain],
+        get_weight: Callable[[Arc], Any],
     ) -> bool:
         """Check if the cycle starting at 'handle' is negative.
 
@@ -268,9 +298,10 @@ class NegCycleFinder(Generic[Node, Arc, Domain]):
         # do while loop in C++
         while True:
             u_node, edge = self.pred[v_node]
-            if dist[v_node] > dist[u_node] + get_weight(
-                edge
-            ):  # Triangle inequality violated
+            tmp = dist[u_node] + get_weight(edge)
+            if isinstance(dist[u_node], int) and isinstance(tmp, float):
+                tmp = int(floor(tmp))
+            if dist[v_node] > tmp:  # Triangle inequality violated
                 return True
             v_node = u_node
             if v_node == handle:  # Completed full cycle
@@ -280,7 +311,7 @@ class NegCycleFinder(Generic[Node, Arc, Domain]):
     def howard(
         self,
         dist: MutableMapping[Node, Domain],
-        get_weight: Callable[[Arc], Domain],
+        get_weight: Callable[[Arc], Any],
     ) -> Generator[Cycle, None, None]:
         """Main algorithm to find negative cycles using Howard's method.
 

{digraphx-0.3 → digraphx-0.4}/src/digraphx/neg_cycle_q.py

@@ -44,11 +44,14 @@ inconsistencies in systems modeled as graphs.
 """
 
 from fractions import Fraction
+from math import floor
 from typing import (
+    Any,
     Callable,
     Dict,
     Generator,
     Generic,
+    Iterable,
     List,
     Mapping,
     MutableMapping,
@@ -66,6 +69,18 @@ Domain = TypeVar("Domain", int, Fraction, float)  # Comparable Ring
 Cycle = List[Arc]  # List of Arcs
 
 
+def _view_items(container: Iterable[Tuple[Node, Arc]]) -> Iterable[Tuple[Node, Arc]]:
+    """Get a pair-iterable view of a neighbor container.
+
+    Mirrors C++ `_view_items` in digraphx-cpp/neg_cycle_q.hpp:
+    - For dict-like containers, use .items() to get (key, value) pairs
+    - For list-like containers, iterate directly (each element is a pair)
+    """
+    if isinstance(container, dict):
+        return container.items()
+    return container
+
+
 class NegCycleFinderQ(Generic[Node, Arc, Domain]):
     """Negative Cycle Finder with constraints by Howard's method
 
@@ -90,14 +105,14 @@ class NegCycleFinderQ(Generic[Node, Arc, Domain]):
     # Successor dictionary: maps each node to (successor_node, connecting_edge)
     succ: Dict[Node, Tuple[Node, Arc]]
 
-    def __init__(self, digraph: Mapping[Node, Mapping[Node, Arc]]) -> None:
+    def __init__(self, digraph: Mapping[Node, Iterable[Tuple[Node, Arc]]]) -> None:
         """Initialize the negative cycle finder with a directed graph.
 
         Args:
             digraph: A directed graph represented as a nested mapping:
                 - Outer keys: source nodes
-                - Inner mappings: {target_node: edge} pairs
-                Example: {u: {v: edge_uv, w: edge_uw}, v: {u: edge_vu}}
+                - Inner values: iterables of (target_node, edge) pairs
+                Example: {u: [(v, edge_uv), (w, edge_uw)], v: [(u, edge_vu)]}
         """
         self.digraph = digraph
         self.pred: Dict[Node, Tuple[Node, Arc]] = {}
@@ -147,7 +162,7 @@ class NegCycleFinderQ(Generic[Node, Arc, Domain]):
     def relax_pred(
         self,
         dist: MutableMapping[Node, Domain],
-        get_weight: Callable[[Arc], Domain],
+        get_weight: Callable[[Arc], Any],
         update_ok: Callable[[Domain, Domain], bool],
     ) -> bool:
         """Perform predecessor relaxation step (Bellman-Ford style).
@@ -181,8 +196,11 @@ class NegCycleFinderQ(Generic[Node, Arc, Domain]):
         """
         changed = False
         for u_node, neighbors in self.digraph.items():
-            for v_node, edge in neighbors.items():
-                distance = dist[u_node] + get_weight(edge)
+            for v_node, edge in _view_items(neighbors):
+                tmp = dist[u_node] + get_weight(edge)
+                if isinstance(dist[u_node], int) and isinstance(tmp, float):
+                    tmp = int(floor(tmp))
+                distance = tmp
                 if dist[v_node] > distance and update_ok(dist[v_node], distance):
                     dist[v_node] = distance
                     self.pred[v_node] = (u_node, edge)  # Update predecessor
@@ -192,7 +210,7 @@ class NegCycleFinderQ(Generic[Node, Arc, Domain]):
     def relax_succ(
         self,
         dist: MutableMapping[Node, Domain],
-        get_weight: Callable[[Arc], Domain],
+        get_weight: Callable[[Arc], Any],
         update_ok: Callable[[Domain, Domain], bool],
     ) -> bool:
         """Perform successor relaxation step (reverse Bellman-Ford style).
@@ -223,8 +241,11 @@ class NegCycleFinderQ(Generic[Node, Arc, Domain]):
         """
         changed = False
         for u_node, neighbors in self.digraph.items():
-            for v_node, edge in neighbors.items():
-                distance = dist[v_node] - get_weight(edge)
+            for v_node, edge in _view_items(neighbors):
+                tmp = dist[v_node] - get_weight(edge)
+                if isinstance(dist[v_node], int) and isinstance(tmp, float):
+                    tmp = int(floor(tmp))
+                distance = tmp
                 if dist[u_node] < distance and update_ok(dist[u_node], distance):
                     dist[u_node] = distance
                     self.succ[u_node] = (v_node, edge)  # Update successor
@@ -234,7 +255,7 @@ class NegCycleFinderQ(Generic[Node, Arc, Domain]):
     def howard_pred(
         self,
         dist: MutableMapping[Node, Domain],
-        get_weight: Callable[[Arc], Domain],
+        get_weight: Callable[[Arc], Any],
         update_ok: Callable[[Domain, Domain], bool],
     ) -> Generator[Cycle, None, None]:
         """Find negative cycles using predecessor-based Howard's algorithm.
@@ -282,7 +303,7 @@ class NegCycleFinderQ(Generic[Node, Arc, Domain]):
     def howard_succ(
         self,
         dist: MutableMapping[Node, Domain],
-        get_weight: Callable[[Arc], Domain],
+        get_weight: Callable[[Arc], Any],
         update_ok: Callable[[Domain, Domain], bool],
     ) -> Generator[Cycle, None, None]:
         """Find negative cycles using successor-based Howard's algorithm.
@@ -363,7 +384,7 @@ class NegCycleFinderQ(Generic[Node, Arc, Domain]):
         self,
         handle: Node,
         dist: MutableMapping[Node, Domain],
-        get_weight: Callable[[Arc], Domain],
+        get_weight: Callable[[Arc], Any],
     ) -> bool:
         """Verify if the cycle starting at handle is negative.
 
@@ -396,8 +417,11 @@ class NegCycleFinderQ(Generic[Node, Arc, Domain]):
         # C-style do-while loop
         while True:
             u_node, edge = self.pred[v_node]
-            if dist[v_node] > dist[u_node] + get_weight(edge):
-                return True  # Found negative cycle
+            tmp = dist[u_node] + get_weight(edge)
+            if isinstance(dist[u_node], int) and isinstance(tmp, float):
+                tmp = int(floor(tmp))
+            if dist[v_node] > tmp:  # Found negative cycle
+                return True
             v_node = u_node
             if v_node == handle:  # Completed full cycle
                 break

{digraphx-0.3 → digraphx-0.4/src/digraphx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digraphx
-Version: 0.3
+Version: 0.4
 Summary: Network Optimization Python Code
 Home-page: https://github.com/luk036/digraphx
 Author: Wai-Shing Luk

digraphx-0.4/src/digraphx.egg-info/SOURCES.txt

@@ -0,0 +1,77 @@
+.coveragerc
+.gitignore
+.isort.cfg
+.pre-commit-config.yaml
+.readthedocs.yml
+AGENTS.md
+AUTHORS.md
+CHANGELOG.md
+CONTRIBUTING.md
+GEMINI.md
+IFLOW.md
+LICENSE
+LICENSE.txt
+README.md
+coverage.json
+environment.yml
+mypy.ini
+note.md
+pyproject.toml
+requirements.txt
+setup.cfg
+setup.py
+tox.ini
+.github/workflows/ci.bak
+.github/workflows/jekyll-gh-pages.yml
+.github/workflows/multi-platforms.yml
+.github/workflows/python-app.yml
+.github/workflows/python-publish.yml
+.vscode/settings.json
+docs/Makefile
+docs/authors.md
+docs/changelog.md
+docs/conf.py
+docs/contributing.md
+docs/index.md
+docs/license.md
+docs/readme.md
+docs/requirements.txt
+docs/_static/.gitignore
+experiments/plot_node_colormap.ipynb
+experiments/plot_node_colormap.py
+requirements/README.md
+requirements/default.txt
+requirements/doc.txt
+requirements/test.txt
+src/digraphx/__init__.py
+src/digraphx/min_cycle_ratio.py
+src/digraphx/min_parametric_q.py
+src/digraphx/neg_cycle.py
+src/digraphx/neg_cycle_q.py
+src/digraphx/parametric.py
+src/digraphx/py.typed
+src/digraphx/tiny_digraph.py
+src/digraphx.egg-info/PKG-INFO
+src/digraphx.egg-info/SOURCES.txt
+src/digraphx.egg-info/dependency_links.txt
+src/digraphx.egg-info/not-zip-safe
+src/digraphx.egg-info/requires.txt
+src/digraphx.egg-info/top_level.txt
+tests/__init__.py
+tests/conftest.py
+tests/test_cycle_ratio.py
+tests/test_delay_padding_example_howard.py
+tests/test_edge_cases.py
+tests/test_howard_cycle_cancellation.py
+tests/test_min_cycle_ratio_property.py
+tests/test_min_parametric_q.py
+tests/test_neg_cycle.py
+tests/test_neg_cycle_q.py
+tests/test_neg_cycle_q_simple_timing.py
+tests/test_neg_cycle_simple_timing.py
+tests/test_parametric.py
+tests/test_stress.py
+tests/test_timing_example.py
+tests/test_timing_example_howard.py
+tests/test_tiny_digraph.py
+tests/test_tiny_digraph_property.py

{digraphx-0.3 → digraphx-0.4}/tests/test_delay_padding_example_howard.py

@@ -83,7 +83,7 @@ def test_even1() -> None:
         "v2": {"v1": {"type": "h", "delay": 4}, "v3": {"type": "p", "delay": 0}},
         "v3": {"v1": {"type": "s", "delay": TCP - 3}},
     }
-    dist: Dict[str, float] = {"v1": 0, "v2": 0, "v3": 0}
+    dist: Dict[str, float] = {"v1": 0.0, "v2": 0.0, "v3": 0.0}
     beta, num_iter, _ = even(digraph, 10, dist)
     assert num_iter < 10
     assert beta == approx(1.5)
@@ -108,7 +108,14 @@ def test_even2() -> None:
         "v4": {"v3": {"type": "s", "delay": TCP - 8}, "v5": {"type": "h", "delay": 3}},
         "v5": {"v4": {"type": "s", "delay": TCP - 3}},
     }
-    dist: Dict[str, float] = {"v0": 0, "v1": 0, "v2": 0, "v3": 0, "v4": 0, "v5": 0}
+    dist: Dict[str, float] = {
+        "v0": 0.0,
+        "v1": 0.0,
+        "v2": 0.0,
+        "v3": 0.0,
+        "v4": 0.0,
+        "v5": 0.0,
+    }
     beta, num_iter, _ = even(digraph, 10, dist)
     print("slack02(s) = {}".format(TCP - 7 + dist["v2"] - dist["v0"]))
     print("slack02(h) = {}".format(6 + dist["v0"] - dist["v2"]))

{digraphx-0.3 → digraphx-0.4}/tests/test_edge_cases.py

@@ -11,7 +11,7 @@ from digraphx.neg_cycle import NegCycleFinder
 from digraphx.tiny_digraph import DiGraphAdapter, TinyDiGraph
 
 
-def test_empty_graph_neg_cycle():
+def test_empty_graph_neg_cycle() -> None:
     """Test negative cycle finder on completely empty graph."""
     graph = DiGraphAdapter()
     dist: Dict[str, Fraction] = {}
@@ -21,7 +21,7 @@ def test_empty_graph_neg_cycle():
     assert len(cycles) == 0
 
 
-def test_single_node_no_edges():
+def test_single_node_no_edges() -> None:
     """Test graph with single node and no edges."""
     graph = DiGraphAdapter()
     graph.add_node(0)
@@ -32,7 +32,7 @@ def test_single_node_no_edges():
     assert len(cycles) == 0
 
 
-def test_single_node_self_loop_negative():
+def test_single_node_self_loop_negative() -> None:
     """Test single node with negative self-loop."""
     graph = DiGraphAdapter()
     graph.add_edge(0, 0, weight=-1)
@@ -43,7 +43,7 @@ def test_single_node_self_loop_negative():
     assert len(cycles) > 0
 
 
-def test_single_node_self_loop_positive():
+def test_single_node_self_loop_positive() -> None:
     """Test single node with positive self-loop."""
     graph = DiGraphAdapter()
     graph.add_edge(0, 0, weight=5)
@@ -54,7 +54,7 @@ def test_single_node_self_loop_positive():
     assert len(cycles) == 0
 
 
-def test_disconnected_components():
+def test_disconnected_components() -> None:
     """Test graph with multiple disconnected components."""
     graph = DiGraphAdapter()
 
@@ -75,7 +75,7 @@ def test_disconnected_components():
     assert len(cycles) > 0
 
 
-def test_tiny_digraph_init_zero_nodes():
+def test_tiny_digraph_init_zero_nodes() -> None:
     """Test TinyDiGraph initialization with zero nodes."""
     graph = TinyDiGraph()
     graph.init_nodes(0)
@@ -84,7 +84,7 @@ def test_tiny_digraph_init_zero_nodes():
     assert graph.number_of_edges() == 0
 
 
-def test_tiny_digraph_add_edge_before_init():
+def test_tiny_digraph_add_edge_before_init() -> None:
     """Test adding edge before initializing nodes."""
     graph = TinyDiGraph()
 
@@ -92,7 +92,7 @@ def test_tiny_digraph_add_edge_before_init():
         graph.add_edge(0, 1, weight=1)
 
 
-def test_non_numeric_weights():
+def test_non_numeric_weights() -> None:
     """Test that algorithm works with non-numeric weight types."""
     graph = DiGraphAdapter()
     graph.add_edge("a", "b", weight=Fraction(1, 2))
@@ -105,7 +105,7 @@ def test_non_numeric_weights():
     assert len(cycles) > 0
 
 
-def test_mixed_node_types():
+def test_mixed_node_types() -> None:
     """Test graph with mixed node types (strings and ints)."""
     graph = DiGraphAdapter()
     graph.add_edge("a", 0, weight=1)
@@ -118,7 +118,7 @@ def test_mixed_node_types():
     assert len(cycles) > 0
 
 
-def test_zero_weight_cycle():
+def test_zero_weight_cycle() -> None:
     """Test cycle with all zero weights."""
     graph = DiGraphAdapter()
     graph.add_edge(0, 1, weight=0)
@@ -131,7 +131,7 @@ def test_zero_weight_cycle():
     assert len(cycles) == 0  # Zero cycle is not negative
 
 
-def test_very_large_weights():
+def test_very_large_weights() -> None:
     """Test with very large weight values."""
     graph = DiGraphAdapter()
     large_weight = 10**15
@@ -145,7 +145,7 @@ def test_very_large_weights():
     assert len(cycles) > 0
 
 
-def test_digraph_adapter_mixed_edge_attributes():
+def test_digraph_adapter_mixed_edge_attributes() -> None:
     """Test DiGraphAdapter with mixed edge attributes."""
     graph = DiGraphAdapter()
     graph.add_edge("a", "b", weight=5, cost=10, time=2, label="edge1")
@@ -157,7 +157,7 @@ def test_digraph_adapter_mixed_edge_attributes():
     assert graph["a"]["b"]["label"] == "edge1"
 
 
-def test_min_cycle_ratio_empty_graph():
+def test_min_cycle_ratio_empty_graph() -> None:
     """Test minimum cycle ratio solver on empty graph."""
     graph = DiGraphAdapter()
     dist: Dict[str, Fraction] = {}
@@ -170,7 +170,7 @@ def test_min_cycle_ratio_empty_graph():
     assert len(cycle) == 0
 
 
-def test_min_cycle_ratio_single_node():
+def test_min_cycle_ratio_single_node() -> None:
     """Test minimum cycle ratio solver on single node graph."""
     graph = DiGraphAdapter()
     graph.add_edge("a", "a", cost=5, time=1)
@@ -183,7 +183,7 @@ def test_min_cycle_ratio_single_node():
     assert isinstance(ratio, (Fraction, float))
 
 
-def test_invalid_weight_extraction():
+def test_invalid_weight_extraction() -> None:
     """Test handling of edges with missing weight attributes."""
     graph = DiGraphAdapter()
     graph.add_edge("a", "b", weight=5)
@@ -195,7 +195,7 @@ def test_invalid_weight_extraction():
     assert len(cycles) == 0
 
 
-def test_directed_graph_orientation():
+def test_directed_graph_orientation() -> None:
     """Test that algorithm respects edge direction."""
     graph = DiGraphAdapter()
     graph.add_edge(0, 1, weight=1)
@@ -208,7 +208,7 @@ def test_directed_graph_orientation():
     assert len(cycles) > 0  # 0->1->2->0 forms negative cycle
 
 
-def test_multiple_edges_same_nodes():
+def test_multiple_edges_same_nodes() -> None:
     """Test graph with multiple edges between same node pair (parallel edges)."""
     graph = DiGraphAdapter()
     # NetworkX typically replaces parallel edges, but test behavior
@@ -221,7 +221,7 @@ def test_multiple_edges_same_nodes():
     assert len(cycles) == 0  # Single edge can't form cycle
 
 
-def test_floating_point_weights():
+def test_floating_point_weights() -> None:
     """Test with floating point weights."""
     graph = DiGraphAdapter()
     graph.add_edge(0, 1, weight=0.1)
@@ -234,7 +234,7 @@ def test_floating_point_weights():
     assert len(cycles) > 0
 
 
-def test_negative_self_loop():
+def test_negative_self_loop() -> None:
     """Test negative self-loop detection."""
     graph = DiGraphAdapter()
     graph.add_edge(0, 1, weight=1)
@@ -247,7 +247,7 @@ def test_negative_self_loop():
     assert len(cycles) > 0
 
 
-def test_no_path_between_components():
+def test_no_path_between_components() -> None:
     """Test that negative cycle in one component is detected even when other components exist."""
     graph = DiGraphAdapter()
     # Component 1: no cycle
@@ -262,3 +262,64 @@ def test_no_path_between_components():
     finder = NegCycleFinder(graph)
     cycles = list(finder.howard(dist, lambda edge: edge.get("weight", 1)))
     assert len(cycles) > 0
+
+
+# ── Multi-edge (parallel edge) tests ─────────────────────────────────────────
+
+
+def test_multi_edge_list_of_lists_no_cycle() -> None:
+    """Multi-edge graph using list-of-lists (like C++ test_neg_cycle_raw.cpp).
+
+    Two parallel edges from node 2 to node 0, none forming a negative cycle.
+    """
+    digraph = {
+        0: [(1, 7.0), (2, 5.0)],
+        1: [(0, 0.0), (2, 3.0)],
+        2: [(1, 1.0), (0, 2.0), (0, 1.0)],  # two parallel edges 2→0
+    }
+    dist = {0: 0.0, 1: 0.0, 2: 0.0}
+    finder: NegCycleFinder[int, float, float] = NegCycleFinder(digraph)
+    cycles = list(finder.howard(dist, lambda w: w))
+    assert len(cycles) == 0
+
+
+def test_multi_edge_list_of_lists_with_cycle() -> None:
+    """Multi-edge graph with a negative cycle formed by parallel edges."""
+    digraph = {
+        0: [(1, 1.0)],
+        1: [(2, 1.0)],
+        2: [(0, -3.0), (0, 2.0)],  # one negative, one positive parallel edge
+    }
+    dist = {0: 0.0, 1: 0.0, 2: 0.0}
+    finder: NegCycleFinder[int, float, float] = NegCycleFinder(digraph)
+    cycles = list(finder.howard(dist, lambda w: w))
+    assert len(cycles) > 0
+
+
+def test_multi_edge_q_variant() -> None:
+    """NegCycleFinderQ with multi-edge graph (predecessor variant)."""
+    from digraphx.neg_cycle_q import NegCycleFinderQ
+
+    digraph = {
+        0: [(1, 7.0), (2, 5.0)],
+        1: [(0, 0.0), (2, 3.0)],
+        2: [(1, 1.0), (0, 2.0), (0, 1.0)],  # two parallel edges 2→0
+    }
+    dist = {0: 0.0, 1: 0.0, 2: 0.0}
+    update_ok = lambda old, new: True
+    finder: NegCycleFinderQ[int, float, float] = NegCycleFinderQ(digraph)
+    cycles = list(finder.howard_pred(dist, lambda w: w, update_ok))
+    assert len(cycles) == 0
+
+
+def test_multi_edge_dict_backward_compat() -> None:
+    """Dict-based graphs still work (backward compatibility)."""
+    digraph = {
+        0: {1: 7.0, 2: 5.0},
+        1: {0: 0.0, 2: 3.0},
+        2: {1: 1.0, 0: 2.0},
+    }
+    dist = {0: 0.0, 1: 0.0, 2: 0.0}
+    finder: NegCycleFinder[int, float, float] = NegCycleFinder(digraph)
+    cycles = list(finder.howard(dist, lambda w: w))
+    assert len(cycles) == 0

{digraphx-0.3 → digraphx-0.4}/tests/test_howard_cycle_cancellation.py

@@ -31,7 +31,7 @@ def test_even() -> None:
         "v2": {"v3": TCP - 3.0, "v1": 2.0},
         "v3": {"v1": TCP - 4.0, "v2": 3.0},
     }
-    dist: Dict[str, float] = {"v1": 0, "v2": 0, "v3": 0}
+    dist: Dict[str, float] = {"v1": 0.0, "v2": 0.0, "v3": 0.0}
     beta, num_iter = even(digraph, 10, dist)
     assert num_iter < 4
     assert beta == approx(1.0)
@@ -76,7 +76,7 @@ def test_prop() -> None:
             "v2": {"cost": 3.0, "time": 1.5},
         },
     }
-    dist: Dict[str, float] = {"v1": 0, "v2": 0, "v3": 0}
+    dist: Dict[str, float] = {"v1": 0.0, "v2": 0.0, "v3": 0.0}
     beta, num_iter = prop(digraph, 10, dist)
     assert num_iter < 5
     assert beta == approx(0.3448275862068966)

{digraphx-0.3 → digraphx-0.4}/tests/test_neg_cycle_q_simple_timing.py

@@ -22,17 +22,17 @@ def has_negative_cycle(TCP: float, dist: Dict[str, float]) -> bool:
 
 def test_simple_timing_example1() -> None:
     """Creates a test graph for timing tests."""
-    dist: Dict[str, float] = {"v1": 0, "v2": 0, "v3": 0}
+    dist: Dict[str, float] = {"v1": 0.0, "v2": 0.0, "v3": 0.0}
     assert has_negative_cycle(4.0, dist) is False
 
 
 def test_simple_timing_example2() -> None:
     """Creates a test graph for timing tests."""
-    dist: Dict[str, float] = {"v1": 0, "v2": 0, "v3": 0}
+    dist: Dict[str, float] = {"v1": 0.0, "v2": 0.0, "v3": 0.0}
     assert has_negative_cycle(2.0, dist) is True
 
 
 def test_simple_timing_example3() -> None:
-    dist: Dict[str, float] = {"v1": 0, "v2": 0, "v3": 0}
+    dist: Dict[str, float] = {"v1": 0.0, "v2": 0.0, "v3": 0.0}
     assert has_negative_cycle(3.0, dist) is False
     assert dist == {"v1": 0, "v2": 1, "v3": 1}