In BigIntegers it is faster to use the absolute value of the difference

Author: TilmanNeumann

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

@@ -71,6 +71,7 @@ public BigInteger findSingleFactor(BigInteger N) {
 	    	        final int iMax = Math.min(m, r-k);
 	    	        for (int i=1; i<=iMax; i++) {
 	    	            y = squareAddModN(y, c);
+						// In BigInteger variants it is slightly faster to use the absolute value of the difference
 	    	            final BigInteger diff = x.compareTo(y) < 0 ? y.subtract(x) : x.subtract(y);
 	    	            q = diff.multiply(q).mod(N);
 	    	        }

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

@@ -81,7 +81,9 @@ public BigInteger findSingleFactor(BigInteger N) {
 					for (int i = 1; i <= iMax; i = i + jMax) {
 						for (int j = 0; j < jMax; j++) {
 							y = squareAddModN(y, c);
-							q = q.multiply(x.subtract(y));
+							// In BigInteger variants it is slightly faster to use the absolute value of the difference
+		    	            final BigInteger diff = x.compareTo(y) < 0 ? y.subtract(x) : x.subtract(y);
+		    	            q = diff.multiply(q).mod(N);
 						}
 						q = q.mod(N); // one mod for the block
 					}
@@ -97,7 +99,8 @@ public BigInteger findSingleFactor(BigInteger N) {
 	    	if (G.equals(N)) {
 	    	    do {
 	    	        ys = squareAddModN(ys, c);
-	    	        G = N.gcd(x.subtract(ys));
+    	            final BigInteger diff = x.compareTo(ys) < 0 ? ys.subtract(x) : x.subtract(ys);
+    	            G = diff.gcd(N);
 	    	    } while (G.equals(I_1));
 	    	    if (DEBUG) LOG.debug("G = " + G);
 	    	}

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

@@ -67,7 +67,9 @@ public BigInteger findSingleFactor(BigInteger N) {
 		            x  = squareAddModN(x, c);
 		            xx = squareAddModN(xx, c);
 		            xx = squareAddModN(xx, c);
-		            prod = prod.multiply(x.subtract(xx)).mod(N);
+					// In BigInteger variants it is slightly faster to use the absolute value of the difference
+    	            final BigInteger diff = x.compareTo(xx) < 0 ? xx.subtract(x) : x.subtract(xx);
+		            prod = diff.multiply(prod).mod(N);
 	        	}
 	            gcd = prod.gcd(N);
 	        } while (gcd.equals(I_1));
@@ -76,7 +78,8 @@ public BigInteger findSingleFactor(BigInteger N) {
 		            xs  = squareAddModN(xs, c);
 		            xxs = squareAddModN(xxs, c);
 		            xxs = squareAddModN(xxs, c);
-	    	        gcd = N.gcd(xs.subtract(xxs));
+    	            final BigInteger diff = xs.compareTo(xxs) < 0 ? xxs.subtract(xs) : xs.subtract(xxs);
+	    	        gcd = diff.gcd(N);
 	    	    } while (gcd.equals(I_1));
 	    	}	        
 	    // leave loop if factor found; otherwise continue with a new random c

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

@@ -82,12 +82,14 @@ public BigInteger findSingleFactor(BigInteger N) {
     		            x  = squareAddModN(x, c);
     		            xx = squareAddModN(xx, c);
     		            xx = squareAddModN(xx, c);
-    		            prod = prod.multiply(x.subtract(xx));
+						// In BigInteger variants it is slightly faster to use the absolute value of the difference
+        	            final BigInteger diff = x.compareTo(xx) < 0 ? xx.subtract(x) : x.subtract(xx);
+    		            prod = diff.multiply(prod);
     	        	}
     	        	prod = prod.mod(N);
     	        }
 	            gcd = prod.gcd(N);
-	            // grow the gdBlock like R in Brent
+	            // grow the gdBlock like R in Brent; this improves performance for "larger" N only, like 70 bit or more
 		    	if (gcdBlock<gcdBlockMax) {
 		    		gcdBlock <<= 1;
 		    		if (gcdBlock > gcdBlockMax) gcdBlock = gcdBlockMax;
@@ -99,7 +101,8 @@ public BigInteger findSingleFactor(BigInteger N) {
 		            xs  = squareAddModN(xs, c);
 		            xxs = squareAddModN(xxs, c);
 		            xxs = squareAddModN(xxs, c);
-	    	        gcd = xs.subtract(xxs).gcd(N);
+    	            final BigInteger diff = xs.compareTo(xxs) < 0 ? xxs.subtract(xs) : xs.subtract(xxs);
+	    	        gcd = diff.gcd(N);
 	    	    } while (gcd.equals(I_1));
 	    	}	        
 	    // leave loop if factor found; otherwise continue with a new random c