convert PurePowerTest tests into unit tests etc.

Author: TilmanNeumann

src/main/java/de/tilman_neumann/jml/powers/PurePowerTest.java

@@ -13,11 +13,7 @@
  */
 package de.tilman_neumann.jml.powers;
 
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
 import java.math.BigInteger;
-import java.security.SecureRandom;
-import java.util.ArrayList;
 
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.LogManager;
@@ -27,8 +23,6 @@
 import de.tilman_neumann.jml.primes.exact.AutoExpandingPrimesArray;
 import de.tilman_neumann.jml.roots.Roots;
 import de.tilman_neumann.jml.roots.SqrtExact;
-import de.tilman_neumann.util.Ensure;
-import de.tilman_neumann.util.ConfigUtil;
 
 import static de.tilman_neumann.jml.base.BigIntConstants.*;
 
@@ -43,6 +37,8 @@
 public class PurePowerTest {
 	private static final Logger LOG = LogManager.getLogger(PurePowerTest.class);
 
+	private static final boolean DEBUG = false;
+	
 	private static final double LN_2 = Math.log(2);
 	private static final double LN_3 = Math.log(3);
 
@@ -97,7 +93,7 @@ public Result test_v01(BigInteger N) {
 			// N is even -> we can test bit patterns before the full i.th root
 			BigInteger N_reduced = N.shiftRight(lsb);
 			for (int b = 3; b<log3N; b=primesArray.getPrime(++bIndex)) {
-				//LOG.debug("test b = " + b);
+				if (DEBUG) LOG.debug("test b = " + b);
 				// if the number of trailing zeros in N is not equal to 0 (mod b), then N is not a b.th power
 				if (lsb % b != 0) continue;
 				// full b.th root required
@@ -110,7 +106,7 @@ public Result test_v01(BigInteger N) {
 		} else {
 			// N is odd
 			for (int b = 3; b<log3N; b=primesArray.getPrime(++bIndex)) {
-				//LOG.debug("test b = " + b);
+				if (DEBUG) LOG.debug("test b = " + b);
 				BigInteger floor_bthRoot = Roots.ithRoot(N, b)[0];
 				if (floor_bthRoot.pow(b).equals(N)) {
 					// found exact power!
@@ -191,11 +187,11 @@ public Result test_v01(BigInteger N) {
 				// Sieve out some powers: If (2b+1) is prime, then N = x^b is only possible if N^2 == 1 (mod (2b+1)) or if (2b+1) | N
 				final int b2p = (b<<1) + 1;
 				while (b2 < b2p) b2 = primesArray.getPrime(b2Index++);
-				//LOG.debug("test b = " + b + ", b2 = " + b2);
+				if (DEBUG) LOG.debug("test b = " + b + ", b2 = " + b2);
 				if (b2 == b2p) {
 					// 2*b+1 is prime
 					final int mod = N_square.mod(b2p);
-					//LOG.debug("N = " + N + ", N^2 % b2 = " + mod);
+					if (DEBUG) LOG.debug("N = " + N + ", N^2 % b2 = " + mod);
 					if (mod > 1) continue;
 				}
 				// Full root required.
@@ -220,17 +216,17 @@ public Result test_v01(BigInteger N) {
 		int b2 = 3, b2Index = 1; // skip 2
 		int bIndex = 1; // skip 2
 		for (int b = 3; b<=lsb; b=primesArray.getPrime(++bIndex)) {
-			//LOG.debug("test b = " + b);
+			if (DEBUG) LOG.debug("test b = " + b);
 			// N can only be a b.th power if b | lsb
 			if (lsb % b != 0) continue;
 			// Sieve out some powers: If (2b+1) is prime, then N = x^b is only possible if N^2 == 1 (mod (2b+1)) or if (2b+1) | N
 			final int b2p = (b<<1) + 1;
 			while (b2 < b2p) b2 = primesArray.getPrime(b2Index++);
-			//LOG.debug("test b = " + b + ", b2 = " + b2);
+			if (DEBUG) LOG.debug("test b = " + b + ", b2 = " + b2);
 			if (b2 == b2p) {
 				// 2*b+1 is prime
 				final int mod = N_reduced_square.mod(b2p);
-				//LOG.debug("N = " + N + ", N^2 % b2 = " + mod);
+				if (DEBUG) LOG.debug("N = " + N + ", N^2 % b2 = " + mod);
 				if (mod > 1) continue;
 			}
 			// full b.th root required
@@ -242,93 +238,4 @@ public Result test_v01(BigInteger N) {
 		}
 		return null; // no pure power
 	}
-
-	private static void testCorrectness(int nCount) {
-	   	PurePowerTest powTest = new PurePowerTest();
-
-	   	// create test set for performance test
-	   	SecureRandom rng = new SecureRandom();
-	   	for (int bits=10; bits<=50; bits+=5) {
-	   		LOG.info("Test correctness with " + nCount + " " + bits + "-bit numbers");
-		   	ArrayList<BigInteger> testSet = new ArrayList<BigInteger>();
-		   	for (int i=0; i<nCount; i++) {
-		   		testSet.add(new BigInteger(bits, rng));
-		   	}
-		   	
-		   	// test correctness:
-		   	// pure powers are not unique, e.g. 3^9 == 27^3, thus we can only check if the final result is correct
-		   	for (BigInteger testNum : testSet) {
-		   		Result r1 = powTest.test_v01(testNum);
-	   			if (r1!=null) Ensure.ensureEquals(testNum, r1.base.pow(r1.exponent));
-	   			
-		   		Result r2 = powTest.test/*_v02*/(testNum);
-		   		Ensure.ensureEquals(r1==null, r2==null);
-	   			if (r2!=null) Ensure.ensureEquals(testNum, r2.base.pow(r2.exponent));
-		   	}
-	   	}
-	   	LOG.info("");
-	}
-	
-	private static void testPerformance(int nCount) {
-	   	PurePowerTest powTest = new PurePowerTest();
-
-	   	// create test set for performance test
-	   	SecureRandom rng = new SecureRandom();
-	   	for (int bits=50; ; bits+=50) {
-		   	ArrayList<BigInteger> testSet = new ArrayList<BigInteger>();
-		   	for (int i=0; i<nCount; i++) {
-		   		testSet.add(new BigInteger(bits, rng));
-		   	}
-	
-		   	// test performance
-		   	long t0, t1;
-		   	t0 = System.currentTimeMillis();
-		   	for (BigInteger testNum : testSet) {
-		   		powTest.test_v01(testNum);
-		   	}
-		   	t1 = System.currentTimeMillis();
-			LOG.info("v01: Testing " + nCount + " " + bits + "-bit numbers took " + (t1-t0) + " ms");
-
-		   	t0 = System.currentTimeMillis();
-		   	for (BigInteger testNum : testSet) {
-		   		powTest.test/*_v02*/(testNum);
-		   	}
-		   	t1 = System.currentTimeMillis();
-			LOG.info("v02: Testing " + nCount + " " + bits + "-bit numbers took " + (t1-t0) + " ms");
-			LOG.info("");
-	   	}
-	}
-	
-	private static void testInputs() {
-	   	PurePowerTest powTest = new PurePowerTest();
-	   	while(true) {
-			try {
-				LOG.info("Insert test argument N:");
-				BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
-				String line = in.readLine();
-				String input = line !=null ? line.trim() : "";
-				//LOG.debug("input = >" + input + "<");
-				BigInteger N = new BigInteger(input);
-				Result purePower = powTest.test(N);
-				if (purePower == null) {
-					LOG.info("N = " + N + " is not a pure power.");
-				} else {
-					LOG.info("N = " + N + " = " + purePower.base + "^" + purePower.exponent + " is a pure power!");
-				}
-			} catch (Exception ex) {
-				LOG.error("Error " + ex, ex);
-			}
-		}
-	}
-
-	/**
-	 * Test.
-	 * @param args ignored
-	 */
-	public static void main(String[] args) {
-	   	ConfigUtil.initProject();
-	   	testCorrectness(100000);
-	   	testPerformance(1000000);
-	   	testInputs();
-	}
 }

src/test/java/de/tilman_neumann/jml/powers/PurePowerTestPerformanceTest.java

@@ -0,0 +1,71 @@
+/*
+ * 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]
+ *
+ * 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.powers;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+
+import de.tilman_neumann.util.ConfigUtil;
+
+/**
+ * Test performance of pure power tests.
+ * 
+ * @author Tilman Neumann
+ */
+public class PurePowerTestPerformanceTest {
+	private static final Logger LOG = LogManager.getLogger(PurePowerTestPerformanceTest.class);
+
+	private static void testPerformance(int nCount) {
+	   	PurePowerTest powTest = new PurePowerTest();
+
+	   	// create test set for performance test
+	   	SecureRandom rng = new SecureRandom();
+	   	for (int bits=50; ; bits+=50) {
+		   	ArrayList<BigInteger> testSet = new ArrayList<BigInteger>();
+		   	for (int i=0; i<nCount; i++) {
+		   		testSet.add(new BigInteger(bits, rng));
+		   	}
+	
+		   	// test performance
+		   	long t0, t1;
+		   	t0 = System.currentTimeMillis();
+		   	for (BigInteger testNum : testSet) {
+		   		powTest.test_v01(testNum);
+		   	}
+		   	t1 = System.currentTimeMillis();
+			LOG.info("v01: Testing " + nCount + " " + bits + "-bit numbers took " + (t1-t0) + " ms");
+
+		   	t0 = System.currentTimeMillis();
+		   	for (BigInteger testNum : testSet) {
+		   		powTest.test/*_v02*/(testNum);
+		   	}
+		   	t1 = System.currentTimeMillis();
+			LOG.info("v02: Testing " + nCount + " " + bits + "-bit numbers took " + (t1-t0) + " ms");
+			LOG.info("");
+	   	}
+	}
+
+	/**
+	 * Test.
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+	   	ConfigUtil.initProject();
+	   	testPerformance(1000000);
+	}
+}

src/test/java/de/tilman_neumann/jml/powers/PurePowerTestRunner.java

@@ -0,0 +1,60 @@
+/*
+ * 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]
+ *
+ * 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.powers;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+
+import de.tilman_neumann.jml.powers.PurePowerTest.Result;
+import de.tilman_neumann.util.ConfigUtil;
+
+/**
+ * Test the pure powers by user inputs.
+ * 
+ * @author Tilman Neumann
+ */
+public class PurePowerTestRunner {
+	private static final Logger LOG = LogManager.getLogger(PurePowerTestRunner.class);
+
+	/**
+	 * Test.
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+	   	ConfigUtil.initProject();
+	   	PurePowerTest powTest = new PurePowerTest();
+	   	while(true) {
+			try {
+				LOG.info("Insert test argument N:");
+				BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+				String line = in.readLine();
+				String input = line !=null ? line.trim() : "";
+				//LOG.debug("input = >" + input + "<");
+				BigInteger N = new BigInteger(input);
+				Result purePower = powTest.test(N);
+				if (purePower == null) {
+					LOG.info("N = " + N + " is not a pure power.");
+				} else {
+					LOG.info("N = " + N + " = " + purePower.base + "^" + purePower.exponent + " is a pure power!");
+				}
+			} catch (Exception ex) {
+				LOG.error("Error " + ex, ex);
+			}
+		}
+	}
+}

src/test/java/de/tilman_neumann/jml/powers/PurePowerTestTest.java

@@ -0,0 +1,70 @@
+/*
+ * 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]
+ *
+ * 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.powers;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+
+import org.apache.logging.log4j.Logger;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.apache.logging.log4j.LogManager;
+
+import de.tilman_neumann.jml.powers.PurePowerTest.Result;
+import de.tilman_neumann.util.ConfigUtil;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Unit tests for the pure power test.
+ * 
+ * @author Tilman Neumann
+ */
+// TODO: A p-adic implementation like in gmp would be much faster for large numbers (with thousands of digits)
+public class PurePowerTestTest {
+	private static final Logger LOG = LogManager.getLogger(PurePowerTestTest.class);
+
+	private static final int NCOUNT = 100000;
+	
+	private static final PurePowerTest powTest = new PurePowerTest();
+	private static final SecureRandom rng = new SecureRandom();
+
+	@BeforeClass
+	public static void setup() {
+		ConfigUtil.initProject();
+	}
+
+	@Test
+	public void testRandomNumbers() {
+	   	for (int bits=10; bits<=50; bits+=5) {
+		   	// create test set
+	   		LOG.info("Test correctness with " + NCOUNT + " " + bits + "-bit numbers");
+		   	ArrayList<BigInteger> testSet = new ArrayList<BigInteger>();
+		   	for (int i=0; i<NCOUNT; i++) {
+		   		testSet.add(new BigInteger(bits, rng));
+		   	}
+		   	
+		   	// pure powers are not unique, e.g. 3^9 == 27^3, thus we can only check if the final result is correct
+		   	for (BigInteger testNum : testSet) {
+		   		Result r1 = powTest.test_v01(testNum);
+	   			if (r1!=null) assertEquals(testNum, r1.base.pow(r1.exponent));
+	   			
+		   		Result r2 = powTest.test/*_v02*/(testNum);
+		   		assertEquals(r1==null, r2==null);
+	   			if (r2!=null) assertEquals(testNum, r2.base.pow(r2.exponent));
+		   	}
+	   	}
+	}
+}