improve log (and currently: compare small algorithms)

Author: TilmanNeumann

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

@@ -77,22 +77,22 @@ private enum TestMode {
 
 	// algorithm options
 	/** number of test numbers */
-	private static final int N_COUNT = 1000000;
+	private static final int N_COUNT = 100000;
 	/** the bit size of N to start with */
-	private static final int START_BITS = 20;
+	private static final int START_BITS = 45;
 	/** the increment in bit size from test set to test set */
-	private static final int INCR_BITS = 1;
+	private static final int INCR_BITS = 5;
 	/** maximum number of bits to test (no maximum if null) */
-	private static final Integer MAX_BITS = 31;
+	private static final Integer MAX_BITS = 45;
 	/** each algorithm is run REPEATS times for each input in order to reduce GC influence on timings */
-	private static final int REPEATS = 1;
+	private static final int REPEATS = 5;
 	/** number of warmup rounds */
-	private static final int WARUMPS = 0;
+	private static final int WARUMPS = 2;
 
 	/** Nature of test numbers */
-	private static final TestNumberNature TEST_NUMBER_NATURE = TestNumberNature.MODERATE_SEMIPRIMES;
+	private static final TestNumberNature TEST_NUMBER_NATURE = TestNumberNature.RANDOM_ODD_COMPOSITES;
 	/** Test mode */
-	private static final TestMode TEST_MODE = TestMode.FIRST_FACTOR;
+	private static final TestMode TEST_MODE = TestMode.PRIME_FACTORIZATION;
 
 	private BPSWTest bpsw = new BPSWTest();
 
@@ -106,9 +106,9 @@ public FactorizerTest() {
 
 			// Trial division
 //			new TDiv31(),
-//			new TDiv31Inverse(),
-//			new TDiv31Barrett(), // Fastest algorithm for N < 29 bit
-//			new TDiv63Inverse(1<<21),
+			new TDiv31Inverse(),
+			new TDiv31Barrett(), // Fastest algorithm for N < 29 bit
+			new TDiv63Inverse(1<<21),
 //			new TDiv().setTestLimit(1<<20),
 
 			// Hart's one line factorizer
@@ -121,23 +121,26 @@ public FactorizerTest() {
 //			new HartFast2Mult(false), // best algorithm for semiprime N for 38 to 45 bit
 //			new HartFast2MultFMA(false),
 //			new HartMultiplierChainSqrtN(false),
+			new HartFast2Mult(true), // best algorithm for semiprime N for 38 to 45 bit
+			new HartFast2MultFMA(true),
+			new HartFast2Mult2(true), // best algorithm for semiprime N for 38 to 45 bit
 
 			// Lehman
 			//new LehmanSimple(false),
 			//new LehmanSmith(false),
 //			new LehmanFast(false), // the variant implemented by bsquared
 			//new LehmanFast(true),
-//			new LehmanCustomKOrder(false),
+			new LehmanCustomKOrder(true),
 
 			// PollardRho
-			new PollardRho31(),
-			new PollardRhoBrent31(),
-			new PollardRhoTwoLoops31(),
+//			new PollardRho31(),
+//			new PollardRhoBrent31(),
+//			new PollardRhoTwoLoops31(),
 			new PollardRhoBrentMontgomery32(),
 
 			//new PollardRhoBrentMontgomery64(),
-			//new PollardRhoBrentMontgomery64MH(),
-			//new PollardRhoBrentMontgomery64MHInlined(),
+			new PollardRhoBrentMontgomery64MH(),
+			new PollardRhoBrentMontgomery64MHInlined(),
 
 			//new PollardRho(),
 			//new PollardRhoProductGcd(),
@@ -151,9 +154,9 @@ public FactorizerTest() {
 			// * SquFoF31 works until 52 bit and is faster there than SquFoF63
 			// * best multiplier sequence = 1680 * {squarefree sequence}
 			// * best stopping criterion = O(5.th root(N))
-//			new SquFoF63(),
+			new SquFoF63(),
 			//new SquFoF31(),
-			//new SquFoF31Preload(),
+			new SquFoF31Preload(),
 
 			// CFrac
 			// * never the best algorithm: SquFoF63 is better for N <= 65 bit, SIQS is better for N >= 55 bits
@@ -168,8 +171,8 @@ public FactorizerTest() {
 
 			// ECM
 //			new TinyEcm64(),
-//			new TinyEcm64MH(),
-//			new TinyEcm64MHInlined(), // best algorithm for N from 46 to 62 bit
+			new TinyEcm64MH(),
+			new TinyEcm64MHInlined(), // best algorithm for N from 46 to 62 bit
 //			new EllipticCurveMethod(-1),
 
 			// SIQS:
@@ -193,20 +196,20 @@ public FactorizerTest() {
 			// Multi-threaded SIQS:
 			// On a Ryzen 3900X, Cmult=0.31 seems to be best for N <= 345 bit, Cmult=0.305 best for N > 345 bit.
 			// Probably, this depends heavily on the number of threads and the hardware, in particular the size of the L3-Cache.
-//			new PSIQS(0.31F, 0.37F, null, 20, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
-	//		new PSIQS_U(0.31F, 0.37F, null, 20, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
-//			new PSIQS_U(0.31F, 0.37F, null, 20, new NoPowerFinder(), new MatrixSolverPGauss01(12)),
-//			new PSIQS_U(0.31F, 0.37F, null, 20, new PowerOfSmallPrimesFinder(), new MatrixSolverBlockLanczos()),
-//			new PSIQS_U(0.31F, 0.37F, null, 20, new AllPowerFinder(), new MatrixSolverBlockLanczos()),
+//			new PSIQS(0.31F, 0.37F, null, 12, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
+	//		new PSIQS_U(0.31F, 0.37F, null, 12, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
+//			new PSIQS_U(0.31F, 0.37F, null, 12, new NoPowerFinder(), new MatrixSolverPGauss01(12)),
+//			new PSIQS_U(0.31F, 0.37F, null, 12, new PowerOfSmallPrimesFinder(), new MatrixSolverBlockLanczos()),
+//			new PSIQS_U(0.31F, 0.37F, null, 12, new AllPowerFinder(), new MatrixSolverBlockLanczos()),
 
 			// experimental PSIQS variants
-//			new PSIQS_U_nLP(0.31F, 0.37F, null, 20, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
-//			new PSIQS_U_3LP(0.31F, 0.37F, null, 20, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
-//			new PSIQS_SB_U(0.31F, 0.37F, null, 20, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
-//			new PSIQS_SB(0.31F, 0.37F, null, 20, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
+//			new PSIQS_U_nLP(0.31F, 0.37F, null, 12, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
+//			new PSIQS_U_3LP(0.31F, 0.37F, null, 12, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
+//			new PSIQS_SB_U(0.31F, 0.37F, null, 12, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
+//			new PSIQS_SB(0.31F, 0.37F, null, 12, new NoPowerFinder(), new MatrixSolverBlockLanczos()),
 
 			// Best combination of sub-algorithms for general factor arguments of any size
-			new CombinedFactorAlgorithm(16, 1<<16, true),
+			new CombinedFactorAlgorithm(12, 1<<16, true),
 		};
 	}
 
@@ -227,7 +230,7 @@ private void testRange(int bits) {
 		}
 
 		if (N_COUNT > 1) {
-			LOG.info("Test " + N_COUNT + " N with " + bits + " bit, e.g. N = " + testNumbers[0]);
+			LOG.info("Test " + REPEATS + "*" + N_COUNT + " N with " + bits + " bit, e.g. N = " + testNumbers[0]);
 		} else {
 			LOG.info("Test N = " + testNumbers[0] + " (" + bits + " bit)");
 		}