Refactor EulerTotientFunction: simplify with trial division, add tests

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: williamfiset

src/main/java/com/williamfiset/algorithms/math/EulerTotientFunction.java

@@ -1,81 +1,49 @@
+/**
+ * Computes Euler's totient function phi(n), which counts the number of integers in [1, n] that are
+ * relatively prime to n.
+ *
+ * <p>Uses trial division to find prime factors and applies the product formula:
+ * phi(n) = n * product of (1 - 1/p) for each distinct prime factor p of n.
+ *
+ * <p>Time: O(sqrt(n))
+ *
+ * @author William Fiset, william.alexandre.fiset@gmail.com
+ */
 package com.williamfiset.algorithms.math;
 
-import java.util.*;
-
 public class EulerTotientFunction {
 
+  /**
+   * Computes Euler's totient phi(n).
+   *
+   * @param n a positive integer.
+   * @return the number of integers in [1, n] that are coprime to n.
+   * @throws IllegalArgumentException if n is not positive.
+   */
   public static long eulersTotient(long n) {
-    for (long p : new HashSet<Long>(primeFactorization(n))) n -= (n / p);
-    return n;
-  }
-
-  private static ArrayList<Long> primeFactorization(long n) {
-    ArrayList<Long> factors = new ArrayList<Long>();
-    if (n <= 0) throw new IllegalArgumentException();
-    else if (n == 1) return factors;
-    PriorityQueue<Long> divisorQueue = new PriorityQueue<Long>();
-    divisorQueue.add(n);
-    while (!divisorQueue.isEmpty()) {
-      long divisor = divisorQueue.remove();
-      if (isPrime(divisor)) {
-        factors.add(divisor);
-        continue;
-      }
-      long next_divisor = pollardRho(divisor);
-      if (next_divisor == divisor) {
-        divisorQueue.add(divisor);
-      } else {
-        divisorQueue.add(next_divisor);
-        divisorQueue.add(divisor / next_divisor);
+    if (n <= 0)
+      throw new IllegalArgumentException("n must be positive.");
+    long result = n;
+    for (long p = 2; p * p <= n; p++) {
+      if (n % p == 0) {
+        while (n % p == 0)
+          n /= p;
+        result -= result / p;
       }
     }
-    return factors;
-  }
-
-  private static long pollardRho(long n) {
-    if (n % 2 == 0) return 2;
-    // Get a number in the range [2, 10^6]
-    long x = 2 + (long) (999999 * Math.random());
-    long c = 2 + (long) (999999 * Math.random());
-    long y = x;
-    long d = 1;
-    while (d == 1) {
-      x = (x * x + c) % n;
-      y = (y * y + c) % n;
-      y = (y * y + c) % n;
-      d = gcf(Math.abs(x - y), n);
-      if (d == n) break;
-    }
-    return d;
-  }
-
-  private static long gcf(long a, long b) {
-    return b == 0 ? a : gcf(b, a % b);
-  }
-
-  private static boolean isPrime(long n) {
-
-    if (n < 2) return false;
-    if (n == 2 || n == 3) return true;
-    if (n % 2 == 0 || n % 3 == 0) return false;
-
-    int limit = (int) Math.sqrt(n);
-
-    for (int i = 5; i <= limit; i += 6) if (n % i == 0 || n % (i + 2) == 0) return false;
-
-    return true;
+    // If n still has a prime factor greater than sqrt(original n).
+    if (n > 1)
+      result -= result / n;
+    return result;
   }
 
   public static void main(String[] args) {
-
-    // Prints 8 because 1,2,4,7,8,11,13,14 are all
-    // less than 15 and relatively prime with 15
+    // phi(15) = 8 because 1,2,4,7,8,11,13,14 are coprime with 15.
     System.out.printf("phi(15) = %d\n", eulersTotient(15));
 
     System.out.println();
 
-    for (int x = 1; x <= 11; x++) {
+    for (int x = 1; x <= 11; x++)
       System.out.printf("phi(%d) = %d\n", x, eulersTotient(x));
-    }
   }
 }

src/test/java/com/williamfiset/algorithms/math/BUILD

@@ -25,3 +25,14 @@ java_test(
     runtime_deps = JUNIT5_RUNTIME_DEPS,
     deps = TEST_DEPS,
 )
+
+# bazel test //src/test/java/com/williamfiset/algorithms/math:EulerTotientFunctionTest
+java_test(
+    name = "EulerTotientFunctionTest",
+    srcs = ["EulerTotientFunctionTest.java"],
+    main_class = "org.junit.platform.console.ConsoleLauncher",
+    use_testrunner = False,
+    args = ["--select-class=com.williamfiset.algorithms.math.EulerTotientFunctionTest"],
+    runtime_deps = JUNIT5_RUNTIME_DEPS,
+    deps = TEST_DEPS,
+)

src/test/java/com/williamfiset/algorithms/math/EulerTotientFunctionTest.java

@@ -0,0 +1,55 @@
+package com.williamfiset.algorithms.math;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.*;
+
+public class EulerTotientFunctionTest {
+
+  // Known values: https://oeis.org/A000010
+  private static final long[] EXPECTED = {
+    0, 1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18, 8
+  };
+
+  @Test
+  public void testKnownValues() {
+    for (int n = 1; n < EXPECTED.length; n++)
+      assertThat(EulerTotientFunction.eulersTotient(n)).isEqualTo(EXPECTED[n]);
+  }
+
+  @Test
+  public void testOne() {
+    assertThat(EulerTotientFunction.eulersTotient(1)).isEqualTo(1);
+  }
+
+  @Test
+  public void testPrimeReturnsPMinusOne() {
+    int[] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 97};
+    for (int p : primes)
+      assertThat(EulerTotientFunction.eulersTotient(p)).isEqualTo(p - 1);
+  }
+
+  @Test
+  public void testPowerOfTwo() {
+    // phi(2^k) = 2^(k-1)
+    for (int k = 1; k <= 20; k++)
+      assertThat(EulerTotientFunction.eulersTotient(1L << k)).isEqualTo(1L << (k - 1));
+  }
+
+  @Test
+  public void testLargeValue() {
+    // phi(1000000) = 400000
+    assertThat(EulerTotientFunction.eulersTotient(1000000)).isEqualTo(400000);
+  }
+
+  @Test
+  public void testZeroThrows() {
+    assertThrows(IllegalArgumentException.class, () -> EulerTotientFunction.eulersTotient(0));
+  }
+
+  @Test
+  public void testNegativeThrows() {
+    assertThrows(IllegalArgumentException.class, () -> EulerTotientFunction.eulersTotient(-5));
+  }
+}