feat: add euler primality test

Author: saahilmahato

src/main/java/com/thealgorithms/maths/Prime/EulerPseudoprime.java

@@ -0,0 +1,105 @@
+package com.thealgorithms.maths.Prime;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+
+/**
+ * The {@code EulerPseudoprime} class implements the Euler primality test.
+ *
+ * It is based on Euler’s criterion:
+ * For an odd prime number {@code n} and any integer {@code a} coprime to {@code n}:
+ *   a^((n-1)/2) ≡ (a/n) (mod n)
+ * where (a/n) is the Jacobi symbol.
+ *
+ * This algorithm is a stronger probabilistic test than Fermat’s test.
+ * It may still incorrectly identify a composite as “probably prime” (Euler pseudoprime),
+ * but such cases are rare.
+ */
+public class EulerPseudoprime {
+
+    private EulerPseudoprime() {
+    }
+
+    private static final SecureRandom random = new SecureRandom();
+
+    /**
+     * Performs the Euler primality test for a given number.
+     *
+     * @param n     number to test (must be > 2 and odd)
+     * @param trials number of random bases to test
+     * @return {@code true} if {@code n} passes all Euler tests (probably prime),
+     *         {@code false} if composite.
+     */
+    public static boolean isProbablePrime(BigInteger n, int trials) {
+        if (n.compareTo(BigInteger.TWO) < 0) {
+            return false;
+        }
+        if (n.equals(BigInteger.TWO) || n.equals(BigInteger.valueOf(3))) {
+            return true;
+        }
+        if (n.mod(BigInteger.TWO).equals(BigInteger.ZERO)) {
+            return false;
+        }
+
+        for (int i = 0; i < trials; i++) {
+            BigInteger a = uniformRandom(BigInteger.TWO, n.subtract(BigInteger.TWO));
+            BigInteger jacobi = BigInteger.valueOf(jacobiSymbol(a, n));
+            if (jacobi.equals(BigInteger.ZERO)) return false;
+
+            BigInteger exp = n.subtract(BigInteger.ONE).divide(BigInteger.TWO);
+            BigInteger modExp = a.modPow(exp, n);
+
+            // Euler's criterion: a^((n-1)/2) ≡ (a/n) (mod n)
+            if (!modExp.equals(jacobi.mod(n))) {
+                return false; // definitely composite
+            }
+        }
+        return true; // probably prime
+    }
+
+    /**
+     * Generates a random BigInteger between {@code min} and {@code max}, inclusive.
+     */
+    private static BigInteger uniformRandom(BigInteger min, BigInteger max) {
+        BigInteger result;
+        do {
+            result = new BigInteger(max.bitLength(), random);
+        } while (result.compareTo(min) < 0 || result.compareTo(max) > 0);
+        return result;
+    }
+
+    /**
+     * Computes the Jacobi symbol (a/n).
+     * Assumes n is positive and odd.
+     */
+    private static int jacobiSymbol(BigInteger a, BigInteger n) {
+        if (n.signum() <= 0 || n.mod(BigInteger.TWO).equals(BigInteger.ZERO)) {
+            throw new IllegalArgumentException("n must be positive and odd.");
+        }
+
+        int result = 1;
+        a = a.mod(n);
+
+        while (a.compareTo(BigInteger.ZERO) != 0) {
+            while (a.mod(BigInteger.TWO).equals(BigInteger.ZERO)) {
+                a = a.divide(BigInteger.TWO);
+                BigInteger nMod8 = n.mod(BigInteger.valueOf(8));
+                if (nMod8.equals(BigInteger.valueOf(3)) || nMod8.equals(BigInteger.valueOf(5))) {
+                    result = -result;
+                }
+            }
+
+            BigInteger temp = a;
+            a = n;
+            n = temp;
+
+            if (a.mod(BigInteger.valueOf(4)).equals(BigInteger.valueOf(3)) && n.mod(BigInteger.valueOf(4)).equals(BigInteger.valueOf(3))) {
+                result = -result;
+            }
+
+            a = a.mod(n);
+        }
+
+        return n.equals(BigInteger.ONE) ? result : 0;
+    }
+}

src/test/java/com/thealgorithms/maths/prime/EulerPseudoprimeTest.java

@@ -0,0 +1,30 @@
+package com.thealgorithms.maths.prime;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import com.thealgorithms.maths.Prime.EulerPseudoprime;
+import java.math.BigInteger;
+import org.junit.jupiter.api.Test;
+
+class EulerPseudoprimeTest {
+
+    @Test
+    void testPrimeNumbers() {
+        assertTrue(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(7), 10));
+        assertTrue(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(13), 10));
+        assertTrue(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(101), 10));
+    }
+
+    @Test
+    void testCompositeNumbers() {
+        assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(9), 10));
+        assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(21), 10));
+        assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(221), 10));
+    }
+
+    @Test
+    void testEvenNumbers() {
+        assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(4), 10));
+        assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(100), 10));
+    }
+}