Refactor to eliminate code duplication between partial and full functions

Extract common cycle-finding logic into helper functions:
- floyd_find_cycle: shared by floyd and floyd_partial
- brent_find_cycle: shared by brent and brent_partial

This eliminates code repetition while maintaining identical behavior.
All tests pass.

Co-authored-by: samueltardieu <44656+samueltardieu@users.noreply.github.com>

Author: Copilot

src/directed/cycle_detection.rs

@@ -1,5 +1,50 @@
 //! Identify a cycle in an infinite sequence.
 
+/// Find the meeting point and lambda using Floyd's algorithm.
+/// Returns (`lambda`, `meeting_element`, `tortoise_steps`).
+fn floyd_find_cycle<T, FS>(start: &T, successor: &FS) -> (usize, T, usize)
+where
+    T: Clone + PartialEq,
+    FS: Fn(T) -> T,
+{
+    let mut tortoise = successor(start.clone());
+    let mut hare = successor(successor(start.clone()));
+    let mut tortoise_steps = 1;
+    while tortoise != hare {
+        (tortoise, hare) = (successor(tortoise), successor(successor(hare)));
+        tortoise_steps += 1;
+    }
+    // tortoise and hare met at position tortoise_steps
+    let mut lam = 1;
+    hare = successor(tortoise.clone());
+    while tortoise != hare {
+        (hare, lam) = (successor(hare), lam + 1);
+    }
+    (lam, tortoise, tortoise_steps)
+}
+
+/// Find the cycle using Brent's algorithm.
+/// Returns (`lambda`, `meeting_element`, `hare_steps`).
+fn brent_find_cycle<T, FS>(start: &T, successor: &FS) -> (usize, T, usize)
+where
+    T: Clone + PartialEq,
+    FS: Fn(T) -> T,
+{
+    let mut power = 1;
+    let mut lam = 1;
+    let mut tortoise = start.clone();
+    let mut hare = successor(start.clone());
+    let mut hare_steps = 1;
+    while tortoise != hare {
+        if power == lam {
+            (tortoise, power, lam) = (hare.clone(), power * 2, 0);
+        }
+        (hare, lam) = (successor(hare), lam + 1);
+        hare_steps += 1;
+    }
+    (lam, hare, hare_steps)
+}
+
 /// Identify a cycle in an infinite sequence using Floyd's algorithm (partial version).
 /// Return the cycle size, an element in the cycle, and an upper bound on the index of
 /// the first element.
@@ -31,19 +76,7 @@ where
     T: Clone + PartialEq,
     FS: Fn(T) -> T,
 {
-    let mut tortoise = successor(start.clone());
-    let mut hare = successor(successor(start.clone()));
-    let mut tortoise_steps = 1;
-    while tortoise != hare {
-        (tortoise, hare) = (successor(tortoise), successor(successor(hare)));
-        tortoise_steps += 1;
-    }
-    // tortoise and hare met at position tortoise_steps
-    let mut lam = 1;
-    hare = successor(tortoise.clone());
-    while tortoise != hare {
-        (hare, lam) = (successor(hare), lam + 1);
-    }
+    let (lam, tortoise, tortoise_steps) = floyd_find_cycle(&start, &successor);
     // Handle edge case where they meet at the start position (pure cycle, mu = 0)
     // In this case, tortoise_steps equals lam, and to satisfy mu_tilde < mu + lam,
     // we must return 0.
@@ -57,26 +90,20 @@ where
 /// # Warning
 ///
 /// If no cycle exist, this function loops forever.
+#[allow(clippy::needless_pass_by_value)]
 pub fn floyd<T, FS>(start: T, successor: FS) -> (usize, T, usize)
 where
     T: Clone + PartialEq,
     FS: Fn(T) -> T,
 {
-    let mut tortoise = successor(start.clone());
-    let mut hare = successor(successor(start.clone()));
-    while tortoise != hare {
-        (tortoise, hare) = (successor(tortoise), successor(successor(hare)));
-    }
+    let (lam, mut tortoise, _tortoise_steps) = floyd_find_cycle(&start, &successor);
+    // Find the exact mu
     let mut mu = 0;
-    tortoise = start;
+    let mut hare = tortoise.clone();
+    tortoise = start.clone();
     while tortoise != hare {
         (tortoise, hare, mu) = (successor(tortoise), successor(hare), mu + 1);
     }
-    let mut lam = 1;
-    hare = successor(tortoise.clone());
-    while tortoise != hare {
-        (hare, lam) = (successor(hare), lam + 1);
-    }
     (lam, tortoise, mu)
 }
 
@@ -113,19 +140,7 @@ where
     T: Clone + PartialEq,
     FS: Fn(T) -> T,
 {
-    let mut power = 1;
-    let mut lam = 1;
-    let mut tortoise = start.clone();
-    let mut hare = successor(start.clone());
-    let mut hare_steps = 1;
-    while tortoise != hare {
-        if power == lam {
-            (tortoise, power, lam) = (hare.clone(), power * 2, 0);
-        }
-        (hare, lam) = (successor(hare), lam + 1);
-        hare_steps += 1;
-    }
-    // At this point, hare has taken hare_steps steps and met tortoise.
+    let (lam, hare, hare_steps) = brent_find_cycle(&start, &successor);
     // Use hare_steps as the upper bound, as it represents where we detected the cycle.
     let mu_tilde = hare_steps;
     (lam, hare, mu_tilde)
@@ -137,23 +152,17 @@ where
 /// # Warning
 ///
 /// If no cycle exist, this function loops forever.
+#[allow(clippy::needless_pass_by_value)]
 pub fn brent<T, FS>(start: T, successor: FS) -> (usize, T, usize)
 where
     T: Clone + PartialEq,
     FS: Fn(T) -> T,
 {
-    let mut power = 1;
-    let mut lam = 1;
-    let mut tortoise = start.clone();
-    let mut hare = successor(start.clone());
-    while tortoise != hare {
-        if power == lam {
-            (tortoise, power, lam) = (hare.clone(), power * 2, 0);
-        }
-        (hare, lam) = (successor(hare), lam + 1);
-    }
+    let (lam, _hare, _hare_steps) = brent_find_cycle(&start, &successor);
+    // Find the exact mu
     let mut mu = 0;
-    (tortoise, hare) = (start.clone(), (0..lam).fold(start, |x, _| successor(x)));
+    let mut tortoise = start.clone();
+    let mut hare = (0..lam).fold(start, |x, _| successor(x));
     while tortoise != hare {
         (tortoise, hare, mu) = (successor(tortoise), successor(hare), mu + 1);
     }