apply first improvement by Dave McGuigan

Author: TilmanNeumann

src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRho31.java

@@ -25,6 +25,9 @@
 /**
  * 31-bit implementation of Pollard's Rho method.
  * 
+ * Improvement by Dave McGuigan:
+ * Use squareAddModN31() instead of nested addModN(squareModN())
+ * 
  * @author Tilman Neumann
  */
 public class PollardRho31 extends FactorAlgorithm {
@@ -55,14 +58,14 @@ public int findSingleFactor(int nOriginal) {
 		this.n = nOriginal<0 ? -nOriginal : nOriginal; // RNG.nextInt(n) below would crash for negative arguments
 
         int gcd;
-        long x = RNG.nextInt(n); // uniform random int from [0, n)
-        long xx = x;
+        int x = RNG.nextInt(n); // uniform random int from [0, n)
+        int xx = x;
         do {
         	int c = RNG.nextInt(n); // uniform random int from [0, n)
 	        do {
-	            x  = addModN(squareModN(x), c);
-	            xx = addModN(squareModN(xx), c);
-	            xx = addModN(squareModN(xx), c);
+	            x  = squareAddModN31(x, c);
+	            xx = squareAddModN31(xx, c);
+	            xx = squareAddModN31(xx, c);
 	            gcd = gcdEngine.gcd((int)(x-xx), n);
 	        } while(gcd==1);
         } while (gcd==n); // leave loop if factor found; otherwise continue with a new random c
@@ -71,22 +74,12 @@ public int findSingleFactor(int nOriginal) {
 	}
 
 	/**
-	 * Addition modulo N, with <code>a, b < N</code>.
-	 * @param a
-	 * @param b
-	 * @return (a+b) mod N
-	 */
-	private long addModN(long a, int b) {
-		long sum = a + b;
-		return sum<n ? sum : sum-n;
-	}
-
-	/**
-	 * x^2 modulo N.
+	 * x^2+c modulo N.
 	 * @param x
 	 * @return
 	 */
-	private long squareModN(long x) {
-		return (x * x) % n;
+	private int squareAddModN31(int x, int c) {
+		// internal computation must be long, not only for the multiplication, but also for the addition of 31 bit numbers
+		return (int)( ((long)x*x+c) % n);
 	}
 }

src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRhoBrent31.java

@@ -27,6 +27,9 @@
  * 
  * 31 bit version.
  * 
+ * Improvement by Dave McGuigan:
+ * Use squareAddModN31() instead of nested addModN(squareModN())
+ * 
  * @author Tilman Neumann
  */
 public class PollardRhoBrent31 extends FactorAlgorithm {
@@ -69,14 +72,14 @@ public int findSingleFactor(int nOriginal) {
         	do {
 	    	    x = y;
 	    	    for (int i=1; i<=r; i++) {
-    	            y = addModN(squareModN(y), c);
+    	            y = squareAddModN31(y, c);
 	    	    }
 	    	    int k = 0;
 	    	    do {
 	    	        ys = y;
 	    	        final int iMax = Math.min(m, r-k);
 	    	        for (int i=1; i<=iMax; i++) {
-	    	            y = addModN(squareModN(y), c);
+	    	            y = squareAddModN31(y, c);
 	    	            final long diff = x<y ? y-x : x-y;
 	    	            q = (int) ((diff*q) % n);
 	    	        }
@@ -90,7 +93,7 @@ public int findSingleFactor(int nOriginal) {
 	    	} while (G==1);
 	    	if (G==n) {
 	    	    do {
-    	            ys = addModN(squareModN(ys), c);
+    	            ys = squareAddModN31(ys, c);
     	            int diff = x<ys ? ys-x : x-ys;
     	            G = gcd.gcd(diff, n);
 	    	    } while (G==1);
@@ -102,22 +105,12 @@ public int findSingleFactor(int nOriginal) {
 	}
 
 	/**
-	 * Addition modulo N, with <code>a, b < N</code>.
-	 * @param a
-	 * @param b
-	 * @return (a+b) mod N
-	 */
-	private int addModN(int a, int b) {
-		long sum = a + (long)b; // long is needed for the addition of 31 bit numbers
-		return (int) (sum<n ? sum : sum-n);
-	}
-
-	/**
-	 * x^2 modulo N.
+	 * x^2+c modulo N.
 	 * @param x
 	 * @return
 	 */
-	private int squareModN(long x) {
-		return (int) ((x * x) % n);
+	private int squareAddModN31(int x, int c) {
+		// internal computation must be long, not only for the multiplication, but also for the addition of 31 bit numbers
+		return (int)( ((long)x*x+c) % n);
 	}
 }