Skip to content

Commit 95fe450

Browse files
TilmanNeumannTilmanNeumann
committed
move executable jar target to class CombinedFactorAlgorithmRunner
1 parent 7acc51a commit 95fe450

File tree

4 files changed

+196
-161
lines changed

4 files changed

+196
-161
lines changed

‎pom.xml

+1-1
Original file line numberDiff line numberDiff line change
@@ -74,7 +74,7 @@
7474
<configuration>
7575
<archive>
7676
<manifest>
77-
<mainClass>de.tilman_neumann.jml.factor.CombinedFactorAlgorithm</mainClass>
77+
<mainClass>de.tilman_neumann.jml.factor.CombinedFactorAlgorithmRunner</mainClass>
7878
</manifest>
7979
</archive>
8080
<descriptorRefs>

‎src/main/java/de/tilman_neumann/jml/base/Rng.java

+7-3
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,8 @@ public class Rng extends Random {
3939

4040
private static final Logger LOG = LogManager.getLogger(Rng.class);
4141

42+
private static final boolean DEBUG = true; // XXX some improvement seems to be possible here
43+
4244
public Rng() {
4345
super();
4446
}
@@ -106,10 +108,12 @@ public long nextLong(long minValue, long maxValue) {
106108
public BigInteger nextBigInteger(BigInteger maxValue) {
107109
int maxBits = maxValue.bitLength()+1;
108110

109-
// do we use the best upper bound?
111+
// do we use the best upper bound? Does not look like that yet!
110112
BigInteger twoPowMaxBits = I_1.shiftLeft(maxBits);
111-
LOG.debug("rng: maxValue = " + maxValue);
112-
LOG.debug("rng: 2^maxBits = " + twoPowMaxBits);
113+
if (DEBUG) {
114+
LOG.debug("rng: maxValue = " + maxValue);
115+
LOG.debug("rng: 2^maxBits = " + twoPowMaxBits);
116+
}
113117

114118
BigInteger randomValue = null;
115119
do {

‎src/main/java/de/tilman_neumann/jml/factor/CombinedFactorAlgorithm.java

-157
Original file line numberDiff line numberDiff line change
@@ -14,13 +14,8 @@
1414
package de.tilman_neumann.jml.factor;
1515

1616
import static de.tilman_neumann.jml.factor.base.GlobalFactoringOptions.*;
17-
import static de.tilman_neumann.jml.base.BigIntConstants.*;
1817

19-
import java.io.BufferedReader;
20-
import java.io.IOException;
21-
import java.io.InputStreamReader;
2218
import java.math.BigInteger;
23-
import java.util.StringTokenizer;
2419

2520
import org.apache.logging.log4j.Logger;
2621
import org.apache.logging.log4j.LogManager;
@@ -49,9 +44,6 @@
4944
import de.tilman_neumann.jml.factor.tdiv.TDiv31Barrett;
5045
import de.tilman_neumann.jml.primes.probable.BPSWTest;
5146
import de.tilman_neumann.util.Ensure;
52-
import de.tilman_neumann.util.ConfigUtil;
53-
import de.tilman_neumann.util.SortedMultiset;
54-
import de.tilman_neumann.util.TimeUtil;
5547

5648
/**
5749
* Final combination of factor algorithms. Integrates trial division and ECM to search small factors of large numbers.
@@ -210,153 +202,4 @@ public void searchFactors(FactorArguments args, FactorResult result) {
210202
else siqsForBigArgs.searchFactors(args, result);
211203
}
212204
}
213-
214-
/**
215-
* Run with command-line arguments or console input (if no command-line arguments are given).
216-
* Usage for executable jar file:
217-
* java -jar <jar_file> [[-t <numberOfThreads>] <numberToFactor>]
218-
*
219-
* Some test numbers:
220-
*
221-
* 15841065490425479923 (64 bit) = 2604221509 * 6082841047
222-
*
223-
* 11111111111111111111111111 (84 bit) = {11=1, 53=1, 79=1, 859=1, 265371653=1, 1058313049=1}
224-
*
225-
* 5679148659138759837165981543 (93 bit) = {3=3, 466932157=1, 450469808245315337=1}
226-
*
227-
* 874186654300294020965320730991996026550891341278308 (170 bit) = {2=2, 3=1, 471997=1, 654743=1, 2855761=1, 79833227=1, 982552477=1, 1052328969055591=1}
228-
*
229-
* 11111111111111111111111111155555555555111111111111111 (173 bit) = {67=1, 157=1, 1056289676880987842105819104055096069503860738769=1} (only tdiv needed)
230-
*
231-
* 1388091470446411094380555803943760956023126025054082930201628998364642 (230 bit) = {2=1, 3=1, 1907=1, 1948073=1, 1239974331653=1, 50222487570895420624194712095309533522213376829=1}
232-
*
233-
* 10^71-1 = 99999999999999999999999999999999999999999999999999999999999999999999999 (236 bit) = {3=2, 241573142393627673576957439049=1, 45994811347886846310221728895223034301839=1}
234-
*
235-
* 10^79+5923 = 10000000000000000000000000000000000000000000000000000000000000000000000000005923 (263 bit) = {1333322076518899001350381760807974795003=1, 7500063320115780212377802894180923803641=1}
236-
*
237-
* 1794577685365897117833870712928656282041295031283603412289229185967719140138841093599 (280 bit) = 42181796536350966453737572957846241893933 * 42543889372264778301966140913837516662044603
238-
*
239-
* 2900608971182010301486951469292513060638582965350239259380273225053930627446289431038392125 (301 bit)
240-
* = 33333 * 33335 * 33337 * 33339 * 33341 * 33343 * 33345 * 33347 * 33349 * 33351 * 33353 * 33355 * 33357 * 33359 * 33361 * 33363 * 33367 * 33369 * 33369 * 33371
241-
* = {3=11, 5=3, 7=6, 11=2, 13=2, 17=2, 19=1, 37=1, 41=1, 53=1, 59=1, 61=1, 73=1, 113=1, 151=1, 227=2, 271=1, 337=1, 433=1, 457=1, 547=1, 953=1, 11113=1, 11117=1, 11119=1, 33343=1, 33347=1, 33349=1, 33353=1, 33359=1}
242-
* (only tdiv)
243-
*
244-
* @param args [-t <numberOfThreads>] <numberToFactor>
245-
*/
246-
public static void main(String[] args) {
247-
ConfigUtil.initProject();
248-
249-
try {
250-
if (args.length==0) {
251-
// test standard input in a loop
252-
testInput();
253-
}
254-
255-
// otherwise we have commandline arguments -> parse them
256-
testArgs(args);
257-
} catch (Exception ite) {
258-
// when the jar is shut down with Ctrl-C, an InvocationTargetException is thrown (log4j?).
259-
// just suppress it and exit
260-
System.exit(0);
261-
}
262-
}
263-
264-
private static int testInput() {
265-
while(true) {
266-
int numberOfThreads = 1;
267-
BigInteger N;
268-
String line = null;
269-
try {
270-
LOG.info("Please insert [-t <numberOfThreads>] <numberToFactor> :");
271-
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
272-
line = in.readLine();
273-
String input = line.trim();
274-
if (input.startsWith("-t")) {
275-
input = input.substring(2).trim();
276-
StringTokenizer parser = new StringTokenizer(input);
277-
numberOfThreads = Integer.parseInt(parser.nextToken().trim());
278-
N = new BigInteger(parser.nextToken().trim());
279-
} else {
280-
N = new BigInteger(input);
281-
}
282-
} catch (IOException ioe) {
283-
LOG.error("IO-error occurring on input: " + ioe.getMessage());
284-
continue;
285-
} catch (NumberFormatException nfe) {
286-
LOG.error("Illegal input: " + line);
287-
continue;
288-
}
289-
test(numberOfThreads, N);
290-
} // next input...
291-
}
292-
293-
private static void testArgs(String[] args) {
294-
int numberOfThreads = 1;
295-
BigInteger N = null;
296-
if (args.length==1) {
297-
try {
298-
N = new BigInteger(args[0].trim());
299-
} catch (NumberFormatException nfe) {
300-
LOG.error("Invalid numberToFactor = " + args[0].trim());
301-
System.exit(-1);
302-
}
303-
} else if (args.length==3) {
304-
if (!args[0].trim().equals("-t")) {
305-
LOG.error("Illegal option: '" + args[0] + "'. Usage: java -jar <jar_file> [-t <numberOfThreads>] <numberToFactor>");
306-
System.exit(-1);
307-
}
308-
try {
309-
numberOfThreads = Integer.parseInt(args[1].trim());
310-
} catch (NumberFormatException nfe) {
311-
LOG.error("Invalid numberOfThreads = " + args[1].trim());
312-
System.exit(-1);
313-
}
314-
try {
315-
N = new BigInteger(args[2].trim());
316-
} catch (NumberFormatException nfe) {
317-
LOG.error("Invalid numberToFactor = " + args[2].trim());
318-
System.exit(-1);
319-
}
320-
} else {
321-
LOG.error("Illegal number of arguments. Usage: java -jar <jar_file> [-t <numberOfThreads>] <numberToFactor>");
322-
System.exit(-1);
323-
}
324-
// run
325-
int exitCode = test(numberOfThreads, N);
326-
System.exit(exitCode);
327-
}
328-
329-
private static int test(int numberOfThreads, BigInteger N) {
330-
if (numberOfThreads < 0) {
331-
LOG.error("numberOfThreads must be positive.");
332-
return -1;
333-
}
334-
if (numberOfThreads > ConfigUtil.NUMBER_OF_PROCESSORS) {
335-
LOG.error("Too big numberOfThreads = " + numberOfThreads + ": Your machine has only " + ConfigUtil.NUMBER_OF_PROCESSORS + " processors");
336-
return -1;
337-
}
338-
339-
// size check
340-
//LOG.debug("N = " + N);
341-
int N_bits = N.bitLength();
342-
if (N.bitLength()>500) {
343-
LOG.error("Too big numberToFactor: Currently only inputs <= 500 bits are supported. (Everything else would take months or years)");
344-
return -1;
345-
}
346-
// run
347-
long t0 = System.currentTimeMillis();
348-
CombinedFactorAlgorithm factorizer = new CombinedFactorAlgorithm(numberOfThreads, null, true);
349-
SortedMultiset<BigInteger> result = factorizer.factor(N);
350-
long duration = System.currentTimeMillis()-t0;
351-
String durationStr = TimeUtil.timeStr(duration);
352-
if (result.totalCount()==0 || (result.totalCount()==1 && result.getSmallestElement().abs().compareTo(I_1)<=0)) {
353-
LOG.info(N + " is trivial");
354-
} else if (result.totalCount()==1 || (result.totalCount()==2 && result.keySet().contains(I_MINUS_1))) {
355-
LOG.info(N + " (" + N_bits + " bits) is probable prime");
356-
} else {
357-
//LOG.debug("result = " + result);
358-
LOG.info(N + " (" + N_bits + " bits) = " + result.toString("*", "^") + " (factored in " + durationStr + ")");
359-
}
360-
return 0;
361-
}
362205
}

0 commit comments

Comments
 (0)