paths: update for fixes in libsemigroups

Author: james-d-mitchell

src/knuth-bendix.cpp

@@ -207,7 +207,7 @@ construct *kb*. This function triggers a full enumeration of *kb*.
     >>> kb = KnuthBendix(congruence_kind.twosided, p)
     >>> kb.number_of_classes()
     +∞
-    >>> list(knuth_bendix.normal_forms(kb).min(1).max(3))
+    >>> list(knuth_bendix.normal_forms(kb).min(1).max(2))
     ['a', 'b', 'c', 'aa', 'ab', 'ac', 'ba', 'bb', 'bc', 'ca', 'cb', 'cc']
 )pbdoc");
 

src/paths.cpp

@@ -451,7 +451,7 @@ The valid values are:
     m.def(
         "paths_number_of_paths_algorithm",
         [](WordGraph<node_type> const& wg, node_type source) {
-          return number_of_paths_algorithm(wg, source);
+          return v4::paths::number_of_paths_algorithm(wg, source);
         },
         py::arg("wg"),
         py::arg("source"),
@@ -481,7 +481,7 @@ with the same arguments.
            node_type                   source,
            size_t                      min,
            int_or_constant<size_t>     max) {
-          return number_of_paths_algorithm(
+          return v4::paths::number_of_paths_algorithm(
               wg, source, min, to_int<size_t>(max));
         },
         py::arg("wg"),
@@ -524,7 +524,7 @@ the range ``[min, max)``.
            node_type                   target,
            size_t                      min,
            int_or_constant<size_t>     max) {
-          return number_of_paths_algorithm(
+          return v4::paths::number_of_paths_algorithm(
               wg, source, target, min, to_int<size_t>(max));
         },
         py::arg("wg"),
@@ -567,7 +567,7 @@ ending at the given target node with length in the range ``[min, max)``.
     m.def(
         "paths_number_of_paths",
         [](WordGraph<node_type> const& wg, node_type source) {
-          return from_int(number_of_paths(wg, source));
+          return from_int(v4::paths::number_of_paths(wg, source));
         },
         py::arg("wg"),
         py::arg("source"),
@@ -611,8 +611,8 @@ This function returns the number of paths in the word graph *wg* starting at
            size_t                      min,
            int_or_constant<size_t>     max,
            paths::algorithm            lgrthm) {
-          return from_int(
-              number_of_paths(wg, source, min, to_int<size_t>(max), lgrthm));
+          return from_int(v4::paths::number_of_paths(
+              wg, source, min, to_int<size_t>(max), lgrthm));
         },
         py::arg("wg"),
         py::arg("source"),
@@ -684,7 +684,8 @@ length in a given range.
            size_t                      min,
            int_or_constant<size_t>     max,
            paths::algorithm            algrthm) {
-          return number_of_paths(wg, source, target, min, to_int<size_t>(max));
+          return v4::paths::number_of_paths(
+              wg, source, target, min, to_int<size_t>(max));
         },
         py::arg("wg"),
         py::arg("source"),

tests/test_paths.py

@@ -140,22 +140,22 @@ def test_paths_number_of_paths():
     assert paths.number_of_paths_algorithm(wg, 0) == paths.algorithm.acyclic
     assert paths.number_of_paths(wg, 0) == POSITIVE_INFINITY
     # source, min, max
-    assert paths.number_of_paths(wg, 0, 0, 10) == 1023
+    assert paths.number_of_paths(wg, 0, 0, 9) == 1023
     # source, target, min, max
-    assert paths.number_of_paths(wg, 0, 1, 0, 10) == 511
+    assert paths.number_of_paths(wg, 0, 1, 0, 9) == 511
 
     assert paths.number_of_paths_algorithm(wg, 1) == paths.algorithm.acyclic
     assert paths.number_of_paths(wg, 1) == POSITIVE_INFINITY
     # source, min, max
-    assert paths.number_of_paths(wg, 1, 0, 10) == 1023
+    assert paths.number_of_paths(wg, 1, 0, 9) == 1023
     assert paths.number_of_paths(wg, 1, 0, POSITIVE_INFINITY) == POSITIVE_INFINITY
 
     assert paths.number_of_paths_algorithm(wg, 2) == paths.algorithm.acyclic
-    assert paths.number_of_paths_algorithm(wg, 2, 0, 10) == paths.algorithm.dfs
+    assert paths.number_of_paths_algorithm(wg, 2, 0, 9) == paths.algorithm.dfs
     assert paths.number_of_paths_algorithm(wg, 2, 0, POSITIVE_INFINITY) == paths.algorithm.trivial
     assert paths.number_of_paths(wg, 2) == POSITIVE_INFINITY
     # source, min, max
-    assert paths.number_of_paths(wg, 2, 0, 10) == 10
+    assert paths.number_of_paths(wg, 2, 0, 9) == 10
     assert (
-        paths.number_of_paths_algorithm(wg, 2, 2, 10, POSITIVE_INFINITY) == paths.algorithm.trivial
+        paths.number_of_paths_algorithm(wg, 2, 2, 9, POSITIVE_INFINITY) == paths.algorithm.trivial
     )