new Pollard-Rho variant by Dave McGuigan

Author: TilmanNeumann

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

@@ -0,0 +1,98 @@
+/*
+ * 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-2025 Tilman Neumann - [email protected]
+ *
+ * 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.factor.pollardRho;
+
+import static de.tilman_neumann.jml.base.BigIntConstants.*;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+
+import de.tilman_neumann.jml.factor.FactorAlgorithm;
+
+/**
+ * An improvement of the original Pollard-Rho method by Dave McGuigan,
+ * using a second loop like in Pollard-Rho-Brent.
+ * 
+ * @author Dave McGuigan
+ */
+public class PollardRhoTwoLoops extends FactorAlgorithm {
+	private static final Logger LOG = LogManager.getLogger(PollardRhoTwoLoops.class);
+	private static final boolean DEBUG = false;
+	private static final SecureRandom RNG = new SecureRandom();
+	
+	private BigInteger N;
+
+	@Override
+	public String getName() {
+		return "PollardRhoTwoLoops";
+	}
+	
+	@Override
+	public BigInteger findSingleFactor(BigInteger N) {
+		this.N = N;
+        BigInteger gcd;
+		int bitLength = N.bitLength();
+		// get random x0 from [0, N-1]
+        BigInteger x = new BigInteger(bitLength, RNG);
+        if (x.compareTo(N)>=0) x=x.subtract(N);
+        BigInteger xx;
+
+        do {
+    		// get random c from [0, N-1]
+        	BigInteger c = new BigInteger(bitLength, RNG);
+            if (c.compareTo(N)>=0) c=c.subtract(N);
+    		
+            xx = x;
+	        BigInteger xs;
+	        BigInteger xxs;
+        	BigInteger prod = I_1;
+        	int m = 100;
+	        do {
+	        	xs = x;
+	        	xxs = xx;
+		        for(int i=0; i<m; i++) {
+		            x  = squareAddModN(x, c);
+		            xx  = squareAddModN(xx, c);
+		            xx  = squareAddModN(xx, c);
+		            prod = prod.multiply(x.subtract(xx)).mod(N);
+	        	}
+	            gcd = prod.gcd(N);
+	        } while(gcd.equals(I_1));
+ 	    	if (gcd.equals(N)) {
+	    	    do {
+		            xs  = squareAddModN(xs, c);
+		            xxs  = squareAddModN(xxs, c);
+		            xxs  = squareAddModN(xxs, c);
+	    	        gcd = N.gcd(xs.subtract(xxs));
+	    	    } while (gcd.equals(I_1));
+	    	}	        
+	    // leave loop if factor found; otherwise continue with a new random c
+        } while (gcd.equals(N));
+        if (DEBUG) LOG.debug("Found factor of " + N + " = " + gcd);
+        return gcd;
+	}
+	
+	/**
+	 * Square and add modulo N, with <code>a, b < N</code>.
+	 * @param y
+	 * @param c
+	 * @return () mod N
+	 */
+	private BigInteger squareAddModN(BigInteger y, BigInteger c) {
+		return y.multiply(y).add(c).mod(N);
+	}
+}

src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRhoTwoLoops31.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 - [email protected]
+ * Copyright (C) 2018-2025 Tilman Neumann - [email protected]
  *
  * 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.
@@ -23,14 +23,10 @@
 import de.tilman_neumann.jml.gcd.Gcd31;
 
 /**
- * 31-bit implementation of Pollard's Rho method with improvements by Dave McGuigan.
+ * An improvement of the original Pollard-Rho method by Dave McGuigan,
+ * using a second loop like in Pollard-Rho-Brent.
  * 
- * Most noteworthy, Dave came up with the second loop in this variant.
- * 
- * Other improvements by Dave used here:
- * 1. Use squareAddModN31() instead of nested addModN(squareModN())
- * 2. Compute the number of steps before each gcd by m=log(n)
- * 3. Use faster "mulMod"
+ * 31-bit version.
  * 
  * @author Dave McGuigan
  */