add another interesting prime test candidate +++ renamed variable

Author: TilmanNeumann

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

@@ -68,15 +68,16 @@ public int findSingleFactor(int N) {
         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 (N, i)) return primes[i];
         }
 
         return -1;
     }
 
     private boolean factorFound(int N, int 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
+    	
         // 1. get pre-computed inverse and limit
         int inv = modularInverses[i];
         int limit = limits[i];

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

@@ -69,15 +69,16 @@ public int findSingleFactor(long N) {
         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 (N, i)) return primes[i];
         }
 
         return -1;
     }
 
     private boolean factorFound(long N, int 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
+    	
         // 1. get pre-computed inverse and limit
         long inv = modularInverses[i];
         long limit = limits[i];

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

@@ -39,16 +39,16 @@ public class AutoExpandingPrimesArray implements SieveCallback {
 	private BinarySearch bs = new BinarySearch();
 
 	// lazy-initialized singleton
-	private static AutoExpandingPrimesArray the_instance = null;
+	private static AutoExpandingPrimesArray theInstance = null;
 
 	/**
 	 * @return the only TDivPrimeTest instance (singleton)
 	 */
 	public static synchronized final AutoExpandingPrimesArray get() {
-		if (the_instance == null) {
-			the_instance = new AutoExpandingPrimesArray();
+		if (theInstance == null) {
+			theInstance = new AutoExpandingPrimesArray();
 		}
-		return the_instance;
+		return theInstance;
 	}
 
 	/**

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

@@ -39,16 +39,16 @@ public class BarrettPrimeTest {
 	private long[] pinv;
 
 	/** lazy-initialized singleton */
-	private static BarrettPrimeTest the_instance = null;
+	private static BarrettPrimeTest theInstance = null;
 
 	/**
 	 * @return the only TDivPrimeTest instance (singleton)
 	 */
 	public static synchronized final BarrettPrimeTest getInstance() {
-		if (the_instance == null) {
-			the_instance = new BarrettPrimeTest();
+		if (theInstance == null) {
+			theInstance = new BarrettPrimeTest();
 		}
-		return the_instance;
+		return theInstance;
 	}
 
 	private BarrettPrimeTest() {

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

@@ -17,6 +17,7 @@
 import org.apache.logging.log4j.LogManager;
 
 import de.tilman_neumann.jml.BinarySearch;
+import de.tilman_neumann.jml.primes.util.PrimeRestsMod30030;
 
 /**
  * A deterministic prime test for N < 32 bit using Lemire division.
@@ -35,26 +36,27 @@ public class LemireIntPrimeTest {
 	private static final int MAX_PRIME_FACTOR = 1<<16; // sufficient for numbers to factor with 32 bits
 
 	private static final BinarySearch binarySeach = new BinarySearch();
-	
+	private PrimeRestsMod30030 primeRestsMod30030 = PrimeRestsMod30030.getInstance();
+
 	private static int MAX_INDEX; // for N<32 bit this would be 4792
 
     private static int[] primes;
     private static int[] modularInverses;
     private static int[] limits;
-	
+
 	// lazy-initialized singleton
-	private static LemireIntPrimeTest the_instance = null;
+	private static LemireIntPrimeTest theInstance = null;
 
 	/**
 	 * @return the only TDivPrimeTest instance (singleton)
 	 */
 	public static synchronized final LemireIntPrimeTest getInstance() {
-		if (the_instance == null) {
-			the_instance = new LemireIntPrimeTest();
+		if (theInstance == null) {
+			theInstance = new LemireIntPrimeTest();
 		}
-		return the_instance;
+		return theInstance;
 	}
-
+	
 	private LemireIntPrimeTest() {
         primes = SmallPrimes.generatePrimes(MAX_PRIME_FACTOR);
         MAX_INDEX = primes.length - 1;
@@ -85,8 +87,6 @@ boolean isPrime_v1(int N) {
 		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;
         }
 
@@ -102,14 +102,38 @@ boolean isPrime_v2(int 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;
     }
 
+	// not public because isPrimeUnrolled() is faster; unrolling this approach did not give a faster variant yet
+	boolean isPrime_v3(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 imax1 = Math.min(imax, 3247);
+		
+		int i = 1;
+        for ( ; i<=imax1; i++) {
+            if (factorFound (N, i)) return false;
+        }
+        
+        if (i < imax) {
+			// Test residues % 30030. Note that N<30030 have been exclude by trial division above.
+			if (!primeRestsMod30030.isPossiblyPrime(N)) return false;
+			
+	        for ( ; i<=imax; i++) {
+	            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;
@@ -137,6 +161,9 @@ boolean isPrime_v2(int N) {
     }
 
     private boolean factorFound(int N, int 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
+    	
         // 1. get pre-computed inverse and limit
         int inv = modularInverses[i];
         int limit = limits[i];

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

@@ -17,6 +17,7 @@
 import org.apache.logging.log4j.LogManager;
 
 import de.tilman_neumann.jml.BinarySearch;
+import de.tilman_neumann.jml.primes.util.PrimeRestsMod30030;
 
 /**
  * A deterministic prime test for N < 32 bit (or even a few bits more) using Lemire division.
@@ -34,24 +35,25 @@ public class LemirePrimeTest {
 	private static final int MAX_PRIME_FACTOR = 1 << ((MAX_N_BITS+1)/2);
 
 	private static final BinarySearch binarySeach = new BinarySearch();
-	
+	private PrimeRestsMod30030 primeRestsMod30030 = PrimeRestsMod30030.getInstance();
+
 	private static int MAX_INDEX; // for N<32 bit this would be 4792
 
     private int[] primes;
     private long[] modularInverses;
     private long[] limits;
 
 	// lazy-initialized singleton
-	private static LemirePrimeTest the_instance = null;
+	private static LemirePrimeTest theInstance = null;
 
 	/**
 	 * @return the only TDivPrimeTest instance (singleton)
 	 */
 	public static synchronized final LemirePrimeTest getInstance() {
-		if (the_instance == null) {
-			the_instance = new LemirePrimeTest();
+		if (theInstance == null) {
+			theInstance = new LemirePrimeTest();
 		}
-		return the_instance;
+		return theInstance;
 	}
 
 	private LemirePrimeTest() {
@@ -84,8 +86,6 @@ boolean isPrime_v1(int N) {
 		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;
         }
 
@@ -101,14 +101,38 @@ boolean isPrime_v2(int 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;
     }
 
+	// not public because isPrimeUnrolled() is faster; unrolling this approach did not give a faster variant yet
+	boolean isPrime_v3(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 imax1 = Math.min(imax, 3247);
+		
+		int i = 1;
+        for ( ; i<=imax1; i++) {
+            if (factorFound (N, i)) return false;
+        }
+        
+        if (i < imax) {
+			// Test residues % 30030. Note that N<30030 have been exclude by trial division above.
+			if (!primeRestsMod30030.isPossiblyPrime(N)) return false;
+			
+	        for ( ; i<=imax; i++) {
+	            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;
@@ -136,6 +160,9 @@ boolean isPrime_v2(int N) {
     }
 
     private boolean factorFound(long N, int 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
+    	
         // 1. get pre-computed inverse and limit
         long inv = modularInverses[i];
         long limit = limits[i];

src/test/java/de/tilman_neumann/jml/primes/exact/TDivPrimeTestPerformanceTest.java

@@ -93,6 +93,13 @@ private static void test() {
 		t1 = System.nanoTime();
 		LOG.info("LEMIRE_TEST.isPrime_v2 took " + (t1-t0) + " ns");
 
+		t0 = System.nanoTime();
+		for (int n : TEST_NUMBERS) {
+			LEMIRE_TEST.isPrime_v3(n);
+		}
+		t1 = System.nanoTime();
+		LOG.info("LEMIRE_TEST.isPrime_v3 took " + (t1-t0) + " ns");
+		
 		t0 = System.nanoTime();
 		for (int n : TEST_NUMBERS) {
 			LEMIRE_TEST.isPrime/*Unrolled*/(n);
@@ -114,6 +121,13 @@ private static void test() {
 		t1 = System.nanoTime();
 		LOG.info("LEMIRE_INT_TEST.isPrime_v2 took " + (t1-t0) + " ns");
 
+		t0 = System.nanoTime();
+		for (int n : TEST_NUMBERS) {
+			LEMIRE_INT_TEST.isPrime_v3(n);
+		}
+		t1 = System.nanoTime();
+		LOG.info("LEMIRE_INT_TEST.isPrime_v3 took " + (t1-t0) + " ns");
+		
 		t0 = System.nanoTime();
 		for (int n : TEST_NUMBERS) {
 			LEMIRE_INT_TEST.isPrime/*Unrolled*/(n);