Skip to content

Commit 90f731d

Browse files
TilmanNeumannTilmanNeumann
committed
new variant of PollardRho31 by Dave McGuigan
1 parent 9da572a commit 90f731d

File tree

2 files changed

+128
-13
lines changed

2 files changed

+128
-13
lines changed

‎src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRhoTwoLoops31.java

+108
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,108 @@
1+
/*
2+
* 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.
3+
* Copyright (C) 2018-2024 Tilman Neumann - [email protected]
4+
*
5+
* This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
6+
* as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
7+
*
8+
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
9+
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
10+
*
11+
* You should have received a copy of the GNU General Public License along with this program;
12+
* if not, see <http://www.gnu.org/licenses/>.
13+
*/
14+
package de.tilman_neumann.jml.factor.pollardRho;
15+
16+
import java.math.BigInteger;
17+
import java.security.SecureRandom;
18+
19+
import org.apache.logging.log4j.Logger;
20+
import org.apache.logging.log4j.LogManager;
21+
22+
import de.tilman_neumann.jml.factor.FactorAlgorithm;
23+
import de.tilman_neumann.jml.gcd.Gcd31;
24+
25+
/**
26+
* 31-bit implementation of Pollard's Rho method with improvements by Dave McGuigan.
27+
*
28+
* Most noteworthy, Dave came up with the second loop in this variant.
29+
*
30+
* Other improvements by Dave used here:
31+
* 1. Use squareAddModN31() instead of nested addModN(squareModN())
32+
* 2. Compute the number of steps before each gcd by m=log(n)
33+
* 3. Use faster "mulMod"
34+
*
35+
* @author Dave McGuigan
36+
*/
37+
public class PollardRhoTwoLoops31 extends FactorAlgorithm {
38+
private static final Logger LOG = LogManager.getLogger(PollardRhoTwoLoops31.class);
39+
private static final boolean DEBUG = false;
40+
private static final SecureRandom RNG = new SecureRandom();
41+
42+
private Gcd31 gcdEngine = new Gcd31();
43+
44+
/** absolute value of the number to factor */
45+
private int n;
46+
47+
@Override
48+
public String getName() {
49+
return "PollardRhoTwoLoops31";
50+
}
51+
52+
@Override
53+
public BigInteger findSingleFactor(BigInteger N) {
54+
if (N.bitLength() > 31) { // this check should be negligible in terms of performance
55+
throw new IllegalArgumentException("N = " + N + " has " + N.bitLength() + " bit, but " + getName() + " only supports arguments <= 31 bit");
56+
}
57+
int factorInt = findSingleFactor(N.intValue());
58+
return BigInteger.valueOf(factorInt);
59+
}
60+
61+
public int findSingleFactor(int nOriginal) {
62+
this.n = nOriginal<0 ? -nOriginal : nOriginal; // RNG.nextInt(n) below would crash for negative arguments
63+
64+
int gcd;
65+
int x = RNG.nextInt(n); // uniform random int from [0, n)
66+
int xs;
67+
int xxs;
68+
69+
final int m = 32 - Integer.numberOfLeadingZeros(n); // ~ ld(n)
70+
do {
71+
int c = RNG.nextInt(n); // uniform random int from [0, n)
72+
73+
int xx = x;
74+
do {
75+
xs = x;
76+
xxs = xx;
77+
int prod = 1;
78+
for (int i=0; i<m; i++) {
79+
x = squareAddModN31(x, c);
80+
xx = squareAddModN31(xx, c);
81+
xx = squareAddModN31(xx, c);
82+
prod = (int) ((((long)x-xx) * prod) % n);
83+
}
84+
gcd = gcdEngine.gcd(prod, n);
85+
if (gcd==n) {
86+
do {
87+
xs = squareAddModN31(xs, c);
88+
xxs = squareAddModN31(xxs, c);
89+
xxs = squareAddModN31(xxs, c);
90+
gcd = gcdEngine.gcd(xs-xxs, n);
91+
} while (gcd == 1);
92+
}
93+
} while (gcd==1);
94+
} while (gcd==n); // leave loop if factor found; otherwise continue with a new random c
95+
if (DEBUG) LOG.debug("Found factor of " + nOriginal + " = " + gcd);
96+
return gcd;
97+
}
98+
99+
/**
100+
* x^2+c modulo N.
101+
* @param x
102+
* @return
103+
*/
104+
private int squareAddModN31(int x, int c) {
105+
// internal computation must be long, not only for the multiplication, but also for the addition of 31 bit numbers
106+
return (int) (((long)x*x+c) % n);
107+
}
108+
}

‎src/test/java/de/tilman_neumann/jml/factor/FactorizerTest.java

+20-13
Original file line numberDiff line numberDiff line change
@@ -110,16 +110,20 @@ public FactorizerTest() {
110110
// new LehmanCustomKOrder(false),
111111

112112
// PollardRho
113+
//new PollardRho31(),
114+
//new PollardRhoBrent31(),
115+
//new PollardRhoTwoLoops31(),
116+
//new PollardRhoBrentMontgomery32(),
117+
118+
//new PollardRhoBrentMontgomeryR64Mul63(),
119+
//new PollardRhoBrentMontgomery64(),
120+
//new PollardRhoBrentMontgomery64MH(),
121+
//new PollardRhoBrentMontgomery64MHInlined(),
122+
113123
//new PollardRho(),
114124
//new PollardRhoProductGcd(),
115125
//new PollardRhoBrent(),
116-
//new PollardRho31(),
117-
//new PollardRhoBrent31(),
118-
// new PollardRhoBrentMontgomeryR64Mul63(),
119-
// new PollardRhoBrentMontgomery64(),
120-
// new PollardRhoBrentMontgomery64MH(),
121-
// new PollardRhoBrentMontgomery64MHInlined(),
122-
126+
123127
// SquFoF variants
124128
// * pretty good, but never the best algorithm
125129
// * SquFoF31 works until 52 bit and is faster there than SquFoF63
@@ -212,17 +216,20 @@ private void testRange(int bits) {
212216
for (FactorAlgorithm algorithm : algorithms) {
213217
// exclude special size implementations
214218
String algName = algorithm.getName();
215-
if (bits<54 && algName.startsWith("SIQS")) continue; // unstable for smaller N
216-
if (bits<57 && algName.startsWith("PSIQS")) continue; // unstable for smaller N
217-
if (bits>98 && algName.startsWith("CFrac63")) continue; // unstable for N>98 bits
218-
if (bits>52 && algName.startsWith("SquFoF31")) continue; // int implementation
219-
if (bits>59 && algName.startsWith("Lehman")) continue; // TODO make it work again for 60 bit?
219+
if (bits>28 && algName.startsWith("HartMultiplierChainSqrtN")) continue; // no multipliers for bigger N
220220
if (bits>31 && algName.startsWith("TDiv31")) continue; // int implementation
221221
if (bits>31 && algName.startsWith("PollardRho31")) continue; // int implementation
222222
if (bits>31 && algName.startsWith("PollardRhoBrent31")) continue; // int implementation
223+
if (bits>31 && algName.startsWith("PollardRhoTwoLoops31")) continue; // int implementation
224+
if (bits>31 && algName.startsWith("PollardRhoBrentMontgomery32")) continue; // int implementation
223225
if (bits>42 && algName.startsWith("TDiv63Inverse")) continue; // not enough primes stored
226+
if (bits>52 && algName.startsWith("SquFoF31")) continue; // int implementation
224227
if (bits>57 && algName.equals("PollardRhoBrentMontgomeryR64Mul63")) continue; // very slow above
225-
if (bits>28 && algName.startsWith("HartMultiplierChainSqrtN")) continue; // no multipliers for bigger N
228+
if (bits>59 && algName.startsWith("Lehman")) continue; // TODO make it work again for 60 bit?
229+
if (bits>63 && algName.startsWith("PollardRhoBrentMontgomery64")) continue; // long implementation
230+
if (bits>98 && algName.startsWith("CFrac63")) continue; // unstable for N>98 bits
231+
if (bits<54 && algName.startsWith("SIQS")) continue; // unstable for smaller N
232+
if (bits<57 && algName.startsWith("PSIQS")) continue; // unstable for smaller N
226233

227234
System.gc(); // create equal conditions for all algorithms
228235

0 commit comments

Comments
 (0)