faster prime test for small N using Lemire division

Author: TilmanNeumann

src/main/java/de/tilman_neumann/jml/factor/tdiv/LemireIntTrialDivision.java

@@ -37,18 +37,17 @@ public class LemireIntTrialDivision extends FactorAlgorithm {
         limits = new int[primes.length];
         for (int i = 0; i < primes.length; i++) {
             int prime = primes[i];
-            // Modulare Inverse für 32-bit (Newton-Verfahren)
+            // compute modular inverses of p (mod 2^32) using Newton's method
             int inv = modularInverseInt(prime);
             modularInverse[i] = inv;
-            // Limit = (2^32 - 1) / prime (Unsigned)
-            // In Java: Integer.divideUnsigned(-1, prime)
+            // limit = (2^32 - 1) / prime (unsigned)
             limits[i] = Integer.divideUnsigned(-1, prime);
         }
     }
 
     private static int modularInverseInt(int n) {
-        int inverse = n;
-        for (int i = 0; i < 4; i++) { // 4 Iterationen reichen für 32-bit
+        int inverse = n; // initial estimate
+        for (int i = 0; i < 4; i++) { // 4 iterations are sufficient for 32 bit numbers
             inverse *= 2 - n * inverse;
         }
         return inverse;
@@ -65,21 +64,21 @@ public BigInteger findSingleFactor(BigInteger N) {
 		return BigInteger.valueOf(findSingleFactor(N.longValue()));
 	}
 
-    public int findSingleFactor(long numberToFactorize) {
+    public int findSingleFactor(long N) {
         // Lemire can not handle even numbers
-        if ((numberToFactorize & 1) == 0) return 2;
+        if ((N & 1) == 0) return 2;
 
         for (int i = 1; i < primes.length; i++) {
             // for hard numbers like big semiprimes finding a factor (early) is unlikely and JIT predicts that
             // the return branch is unlikely -> always the same data processing; preloading the arrays
-            if (factorFound (numberToFactorize, i)) return primes[i];
+            if (factorFound (N, i)) return primes[i];
         }
 
         return -1;
     }
 
-    private boolean factorFound(long numberToFactorize, int i) {
-        int nInt = (int) numberToFactorize;
+    private boolean factorFound(long N, int i) {
+        int nInt = (int) N;
         int product = nInt * modularInverse[i];
         return Integer.compareUnsigned (product, limits[i]) <= 0;
     }

src/main/java/de/tilman_neumann/jml/factor/tdiv/LemireTrialDivision.java

@@ -38,17 +38,17 @@ public class LemireTrialDivision extends FactorAlgorithm {
         limits = new long[primes.length];
         for (int i = 0; i < primes.length; i++) {
             long p = primes[i];
-            // Berechne die modulare Inverse für ungerade p (Newton-Verfahren)
+            // compute modular inverses of p (mod 2^64) using Newton's method
             long inverse = modularInverse(p);
             modularInverse[i] = inverse;
-            // Limit = (2^64 - 1) / p (Unsigned)
+            // limit = (2^64 - 1) / prime (unsigned)
             limits[i] = Long.divideUnsigned(-1L, p);
         }
     }
 
     private static long modularInverse(long n) {
-        long inverse = n; // Initialer Schätzwert
-        for (int i = 0; i < 5; i++) { // 5 Iterationen reichen für 64-bit
+        long inverse = n; // initial estimate
+        for (int i = 0; i < 5; i++) { // 5 iterations are sufficient for 64 bit numbers
             inverse *= 2 - n * inverse;
         }
         return inverse;
@@ -65,30 +65,28 @@ public BigInteger findSingleFactor(BigInteger N) {
 		return BigInteger.valueOf(findSingleFactor(N.longValue()));
 	}
 
-    public int findSingleFactor(long numberToFactorize) {
+    public int findSingleFactor(long N) {
         // Lemire can not handle even numbers
-        if ((numberToFactorize & 1) == 0) return 2;
+        if ((N & 1) == 0) return 2;
 
         for (int i = 1; i < primes.length; i++) {
             // for hard numbers like big semiprimes finding a factor (early) is unlikely and JIT predicts that
             // the return branch is unlikely -> always the same data processing; preloading the arrays
-            if (factorFound (numberToFactorize, i)) return primes[i];
+            if (factorFound (N, i)) return primes[i];
         }
 
         return -1;
     }
 
-    private boolean factorFound(long numberToFactorize, int i) {
-        // 1. Hole vorberechnete Inverse und Limit
+    private boolean factorFound(long N, int i) {
+        // 1. get pre-computed inverse and limit
         long inv = modularInverse[i];
         long limit = limits[i];
 
-        // 2. Multipliziere number * inverse (Überlauf ist beabsichtigt!)
-        long product = numberToFactorize * inv;
+        // 2. multiply number * inverse (overflow is intended!)
+        long product = N * inv;
 
-        // 3. Wenn das Produkt (unsigned) kleiner oder gleich dem Limit ist,
-        // dann ist numberToFactorize restlos durch primes[i] teilbar.
-        // the calculation is done completely in long -> might be the main speedup 50%
+        // 3. if the (unsigned) product is less than or equal to the limit, then primes[i] divides N without rest.
         return  Long.compareUnsigned(product, limit) <= 0;
     }
 }

…n/jml/primes/probable/TDivPrimeTest.java …n/jml/primes/exact/BarrettPrimeTest.javasrc/main/java/de/tilman_neumann/jml/primes/probable/TDivPrimeTest.java renamed to src/main/java/de/tilman_neumann/jml/primes/exact/BarrettPrimeTest.java src/main/java/de/tilman_neumann/jml/primes/probable/TDivPrimeTest.java renamed to src/main/java/de/tilman_neumann/jml/primes/exact/BarrettPrimeTest.java

@@ -1,6 +1,6 @@
 /*
  * java-math-library is a Java library focused on number theory, but not necessarily limited to it. It is based on the PSIQS 4.0 factoring project.
- * Copyright (C) 2018-2024 Tilman Neumann - tilman.neumann@web.de
+ * Copyright (C) 2018-2026 Tilman Neumann - tilman.neumann@web.de
  *
  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
@@ -11,41 +11,47 @@
  * You should have received a copy of the GNU General Public License along with this program;
  * if not, see <http://www.gnu.org/licenses/>.
  */
-package de.tilman_neumann.jml.primes.probable;
+package de.tilman_neumann.jml.primes.exact;
 
 import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.LogManager;
 
-import de.tilman_neumann.jml.primes.exact.AutoExpandingPrimesArray;
+import de.tilman_neumann.jml.BinarySearch;
+
+import org.apache.logging.log4j.LogManager;
 
 /**
- * A deterministic prime test for N < 32 bit using fast trial division.
+ * A deterministic prime test for N < 32 bit using long-valued Barrett trial division.
+ * 
+ * Implements the singleton pattern so that the resources will not be allocated twice no
+ * matter how often the class is used.
  * 
  * @author Tilman Neumann
  */
-public class TDivPrimeTest {
+public class BarrettPrimeTest {
 	@SuppressWarnings("unused")
-	private static final Logger LOG = LogManager.getLogger(TDivPrimeTest.class);
+	private static final Logger LOG = LogManager.getLogger(BarrettPrimeTest.class);
 
 	private static final int NUM_PRIMES_FOR_31_BIT_TDIV = 4793;
 
+	private static final BinarySearch binarySeach = new BinarySearch();
+
 	private int[] primes;
 	private long[] pinv;
 
-	// lazy-initialized singleton
-	private static TDivPrimeTest the_instance = null;
+	/** lazy-initialized singleton */
+	private static BarrettPrimeTest the_instance = null;
 
 	/**
 	 * @return the only TDivPrimeTest instance (singleton)
 	 */
-	public static synchronized final TDivPrimeTest getInstance() {
+	public static synchronized final BarrettPrimeTest getInstance() {
 		if (the_instance == null) {
-			the_instance = new TDivPrimeTest();
+			the_instance = new BarrettPrimeTest();
 		}
 		return the_instance;
 	}
 
-	private TDivPrimeTest() {
+	private BarrettPrimeTest() {
 		AutoExpandingPrimesArray smallPrimesProvider = AutoExpandingPrimesArray.get();
 		primes = new int[NUM_PRIMES_FOR_31_BIT_TDIV];
 		pinv = new long[NUM_PRIMES_FOR_31_BIT_TDIV];
@@ -56,7 +62,37 @@ private TDivPrimeTest() {
 		}
 	}
 
-	public boolean isPrime(int N) {
+	// not public because Lemire is faster
+	boolean isPrime_v1(int N) {
+		if (N==1) return false;
+		if ((N&1)==0) return N==2;
+		
+		// if N is odd and composite then the loop runs maximally up to prime = floor(sqrt(N))
+		int i=1;
+		for ( ; i<NUM_PRIMES_FOR_31_BIT_TDIV; i++) {
+			if ((1 + (int) ((N*pinv[i])>>32)) * primes[i] == N) return primes[i]==N;
+		}
+		// N is prime
+		return true;
+	}
+	
+	// not public because Lemire is faster
+	boolean isPrime_v2(int N) {
+		if (N==1) return false;
+		if ((N&1)==0) return N==2;
+		
+		int pmax = (int) Math.sqrt(N);
+		int imax = binarySeach.getInsertPosition(primes, NUM_PRIMES_FOR_31_BIT_TDIV-1, pmax);
+		
+        for (int i = 1; i<=imax; i++) {
+			if ((1 + (int) ((N*pinv[i])>>32)) * primes[i] == N) return primes[i]==N;
+		}
+		// N is prime
+		return true;
+	}
+
+	// not public because Lemire is faster
+	boolean isPrimeUnrolled(int N) {
 		if (N==1) return false;
 		if ((N&1)==0) return N==2;
 

src/main/java/de/tilman_neumann/jml/primes/exact/LemirePrimeTest.java

@@ -0,0 +1,150 @@
+/*
+ * java-math-library is a Java library focused on number theory, but not necessarily limited to it. It is based on the PSIQS 4.0 factoring project.
+ * Copyright (C) 2018-2026 Tilman Neumann - tilman.neumann@web.de
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program;
+ * if not, see <http://www.gnu.org/licenses/>.
+ */
+package de.tilman_neumann.jml.primes.exact;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+
+import de.tilman_neumann.jml.BinarySearch;
+
+/**
+ * A deterministic prime test for N < 32 bit using Lemire division.
+ * 
+ * Implements the singleton pattern so that the resources will not be allocated twice no
+ * matter how often the class is used.
+ * 
+ * @author Tilman Neumann
+ */
+public class LemirePrimeTest {
+	@SuppressWarnings("unused")
+	private static final Logger LOG = LogManager.getLogger(LemirePrimeTest.class);
+	
+	private static final int MAX_N_BITS = 36;
+	private static final int MAX_PRIME_FACTOR = 1 << ((MAX_N_BITS+1)/2);
+
+	private static final BinarySearch binarySeach = new BinarySearch();
+	
+	private static int MAX_INDEX; // for N<32 bit this would be 4792
+
+    private int[] primes;
+    private long[] modularInverse;
+    private long[] limits;
+	
+	// lazy-initialized singleton
+	private static LemirePrimeTest the_instance = null;
+
+	/**
+	 * @return the only TDivPrimeTest instance (singleton)
+	 */
+	public static synchronized final LemirePrimeTest getInstance() {
+		if (the_instance == null) {
+			the_instance = new LemirePrimeTest();
+		}
+		return the_instance;
+	}
+
+	private LemirePrimeTest() {
+        primes = SmallPrimes.generatePrimes(MAX_PRIME_FACTOR);
+        MAX_INDEX = primes.length - 1;
+        modularInverse = new long[primes.length];
+        limits = new long[primes.length];
+        for (int i = 0; i < primes.length; i++) {
+            long p = primes[i];
+            // compute modular inverses of p (mod 2^64) using Newton's method
+            long inverse = modularInverse(p);
+            modularInverse[i] = inverse;
+            // limit = (2^64 - 1) / p (unsigned)
+            limits[i] = Long.divideUnsigned(-1L, p);
+        }
+    }
+
+    private static long modularInverse(long n) {
+        long inverse = n; // initial estimate
+        for (int i = 0; i < 5; i++) { // 5 iterations are sufficient for 64 bit numbers
+            inverse *= 2 - n * inverse;
+        }
+        return inverse;
+    }
+	
+	// not public because isPrimeUnrolled() is faster
+	boolean isPrime_v1(int N) {
+		if (N==1) return false;
+		if ((N&1)==0) return N==2;
+		
+		int pmax = (int) Math.sqrt(N);
+		
+        for (int i = 1; primes[i]<=pmax; i++) {
+            // for hard numbers like big semiprimes finding a factor (early) is unlikely and JIT predicts that
+            // the return branch is unlikely -> always the same data processing; preloading the arrays
+            if (factorFound (N, i)) return false;
+        }
+        
+        return true;
+    }
+	
+	// not public because isPrimeUnrolled() is faster
+	boolean isPrime_v2(int N) {
+		if (N==1) return false;
+		if ((N&1)==0) return N==2;
+		
+		int pmax = (int) Math.sqrt(N);
+		int imax = binarySeach.getInsertPosition(primes, MAX_INDEX, pmax);
+		
+        for (int i = 1; i<=imax; i++) {
+            // for hard numbers like big semiprimes finding a factor (early) is unlikely and JIT predicts that
+            // the return branch is unlikely -> always the same data processing; preloading the arrays
+            if (factorFound (N, i)) return false;
+        }
+        
+        return true;
+    }
+	
+	public boolean isPrime/*Unrolled*/(int N) {
+		if (N==1) return false;
+		if ((N&1)==0) return N==2;
+		
+		int pmax = (int) Math.sqrt(N);
+		int imax = binarySeach.getInsertPosition(primes, MAX_INDEX, pmax);
+		
+		int i=1;
+		int unrolledLimit = imax-8;
+		for ( ; i<unrolledLimit; i++) {
+            if (factorFound (N, i)) return false;
+            if (factorFound (N, ++i)) return false;
+            if (factorFound (N, ++i)) return false;
+            if (factorFound (N, ++i)) return false;
+            if (factorFound (N, ++i)) return false;
+            if (factorFound (N, ++i)) return false;
+            if (factorFound (N, ++i)) return false;
+            if (factorFound (N, ++i)) return false;
+		}
+		for ( ; i<imax; i++) {
+            if (factorFound (N, i)) return false;
+		}
+        
+        return true;
+    }
+
+    private boolean factorFound(long N, int i) {
+        // 1. get pre-computed inverse and limit
+        long inv = modularInverse[i];
+        long limit = limits[i];
+        
+        // 2. multiply number * inverse (overflow is intended!)
+        long product = N * inv;
+
+        // 3. if the (unsigned) product is less than or equal to the limit, then primes[i] divides N without rest.
+         return  Long.compareUnsigned(product, limit) <= 0;
+    }
+}