Skip to content

Commit 676082e

Browse files
TilmanNeumannTilmanNeumann
committed
converted tests for the computation of i.th roots of integers
1 parent 9bb80cf commit 676082e

File tree

3 files changed

+208
-91
lines changed

3 files changed

+208
-91
lines changed

‎src/main/java/de/tilman_neumann/jml/roots/Roots.java

+1-91
Original file line numberDiff line numberDiff line change
@@ -14,15 +14,12 @@
1414
package de.tilman_neumann.jml.roots;
1515

1616
import java.math.BigInteger;
17-
import java.security.SecureRandom;
18-
import java.util.ArrayList;
1917

2018
import org.apache.logging.log4j.Logger;
2119
import org.apache.logging.log4j.LogManager;
2220

2321
import de.tilman_neumann.jml.base.BigIntConverter;
2422
import de.tilman_neumann.util.Ensure;
25-
import de.tilman_neumann.util.ConfigUtil;
2623

2724
import static de.tilman_neumann.jml.base.BigIntConstants.*;
2825

@@ -41,9 +38,7 @@
4138
*/
4239
public class Roots {
4340
private static final Logger LOG = LogManager.getLogger(Roots.class);
44-
private static final SecureRandom RNG = new SecureRandom();
4541
private static final boolean DEBUG = false;
46-
private static final boolean TEST_BITWISE = false;
4742

4843
/**
4944
* Computes the i.th root of N, using either a bitwise correction approach (for rather big roots <code>i</code>)
@@ -69,7 +64,7 @@ public static BigInteger[] ithRoot(BigInteger N, int i) {
6964
* @param i root
7065
* @return [lower, upper] int values of i.th root(N)
7166
*/
72-
private static BigInteger[] ithRoot_bitwise(BigInteger N, int i) {
67+
static BigInteger[] ithRoot_bitwise(BigInteger N, int i) {
7368
BigInteger ret = I_0;
7469
int maxResultBitIndex = N.bitLength()/i;
7570
for (int bitIdx=maxResultBitIndex; bitIdx>=0; bitIdx--) {
@@ -252,89 +247,4 @@ private static BigInteger computeInitialGuess(BigInteger N, int i) {
252247
//LOG.debug(i + ".th root(" + N + "): initialGuess = " + initialGuess);
253248
return initialGuess;
254249
}
255-
256-
/**
257-
* create test set for performance test: random ints with random bit length < 1000
258-
* @param nCount
259-
* @return
260-
*/
261-
private static ArrayList<BigInteger> createTestSet(int nCount, int bits) {
262-
ArrayList<BigInteger> testSet = new ArrayList<BigInteger>();
263-
for (int i=0; i<nCount;) {
264-
BigInteger testNum = new BigInteger(bits, RNG);
265-
if (testNum.bitLength()<bits) continue; // not exact size, skip
266-
testSet.add(testNum);
267-
i++;
268-
}
269-
return testSet;
270-
}
271-
272-
private static void testCorrectness(int nCount) {
273-
for (int bits = 100; bits<=1000; bits+=100) {
274-
ArrayList<BigInteger> testSet = createTestSet(nCount, bits);
275-
// test correctness
276-
for (BigInteger testNum : testSet) {
277-
int root = 2 + RNG.nextInt(48);
278-
BigInteger[] linResult = Roots.ithRoot_bitwise(testNum, root);
279-
BigInteger[] heronResult = Roots.ithRoot_Heron1(testNum, root);
280-
if (!linResult[0].equals(heronResult[0])) {
281-
LOG.error("ERROR: Heron1: lower bound of " + root + ".th root(" + testNum + "): linear algorithm -> " + linResult[0] + ", Heron1 -> " + heronResult[0]);
282-
}
283-
if (!linResult[1].equals(heronResult[1])) {
284-
LOG.error("ERROR: Heron1: upper bound of " + root + ".th root(" + testNum + "): linear algorithm -> " + linResult[1] + ", Heron1 -> " + heronResult[1]);
285-
}
286-
287-
heronResult = Roots.ithRoot_Heron2(testNum, root);
288-
if (!linResult[0].equals(heronResult[0])) {
289-
LOG.error("ERROR: Heron2: lower bound of " + root + ".th root(" + testNum + "): linear algorithm -> " + linResult[0] + ", Heron2 -> " + heronResult[0]);
290-
}
291-
if (!linResult[1].equals(heronResult[1])) {
292-
LOG.error("ERROR: Heron2: upper bound of " + root + ".th root(" + testNum + "): linear algorithm -> " + linResult[1] + ", Heron2 -> " + heronResult[1]);
293-
}
294-
}
295-
}
296-
}
297-
298-
private static void testPerformance(int nCount) {
299-
for (int bits = 100; ; bits+=100) {
300-
ArrayList<BigInteger> testSet = createTestSet(nCount, bits);
301-
for (int root=3; ((float)bits)/root > 4; root += 1+RNG.nextInt(10)) {
302-
// RNG reduces compiler optimizations ? -> makes test results more comparable ?
303-
LOG.info("test " + root + ".th root of " + bits + "-bit numbers:");
304-
long t0, t1;
305-
if (TEST_BITWISE) {
306-
t0 = System.currentTimeMillis();
307-
for (BigInteger testNum : testSet) {
308-
Roots.ithRoot_bitwise(testNum, root);
309-
}
310-
t1 = System.currentTimeMillis();
311-
LOG.info(" Bitwise ith root test with " + nCount + " numbers took " + (t1-t0) + " ms");
312-
}
313-
314-
t0 = System.currentTimeMillis();
315-
for (BigInteger testNum : testSet) {
316-
Roots.ithRoot_Heron1(testNum, root);
317-
}
318-
t1 = System.currentTimeMillis();
319-
LOG.info(" Heron1 ith root test with " + nCount + " numbers took " + (t1-t0) + " ms");
320-
321-
t0 = System.currentTimeMillis();
322-
for (BigInteger testNum : testSet) {
323-
Roots.ithRoot_Heron2(testNum, root);
324-
}
325-
t1 = System.currentTimeMillis();
326-
LOG.info(" Heron2 ith root test with " + nCount + " numbers took " + (t1-t0) + " ms");
327-
}
328-
}
329-
}
330-
331-
/**
332-
* Test.
333-
* @param args ignored
334-
*/
335-
public static void main(String[] args) {
336-
ConfigUtil.initProject();
337-
testCorrectness(10000);
338-
testPerformance(5000000);
339-
}
340250
}

‎src/test/java/de/tilman_neumann/jml/roots/RootsPerformanceTest.java

+91
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,91 @@
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.roots;
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.util.ConfigUtil;
23+
24+
/**
25+
* Test performance of i.th roots of integers.
26+
*
27+
* @author Tilman Neumann
28+
*/
29+
public class RootsPerformanceTest {
30+
private static final Logger LOG = LogManager.getLogger(RootsPerformanceTest.class);
31+
private static final SecureRandom RNG = new SecureRandom();
32+
private static final boolean TEST_BITWISE = false;
33+
34+
/**
35+
* create test set for performance test: random ints with random bit length < 1000
36+
* @param nCount
37+
* @return
38+
*/
39+
private static BigInteger[] createTestSet(int nCount, int bits) {
40+
BigInteger[] testSet = new BigInteger[nCount];
41+
for (int i=0; i<nCount;) {
42+
BigInteger testNum = new BigInteger(bits, RNG);
43+
if (testNum.bitLength()<bits) continue; // not exact size, skip
44+
testSet[i] = testNum;
45+
i++;
46+
}
47+
return testSet;
48+
}
49+
50+
private static void testPerformance(int nCount) {
51+
for (int bits = 100; ; bits+=100) {
52+
BigInteger[] testSet = createTestSet(nCount, bits);
53+
for (int root=3; ((float)bits)/root > 4; root += 1+RNG.nextInt(10)) {
54+
// RNG reduces compiler optimizations ? -> makes test results more comparable ?
55+
LOG.info("test " + root + ".th root of " + bits + "-bit numbers:");
56+
long t0, t1;
57+
if (TEST_BITWISE) {
58+
t0 = System.currentTimeMillis();
59+
for (BigInteger testNum : testSet) {
60+
Roots.ithRoot_bitwise(testNum, root);
61+
}
62+
t1 = System.currentTimeMillis();
63+
LOG.info(" Bitwise ith root test with " + nCount + " numbers took " + (t1-t0) + " ms");
64+
}
65+
66+
t0 = System.currentTimeMillis();
67+
for (BigInteger testNum : testSet) {
68+
Roots.ithRoot_Heron1(testNum, root);
69+
}
70+
t1 = System.currentTimeMillis();
71+
LOG.info(" Heron1 ith root test with " + nCount + " numbers took " + (t1-t0) + " ms");
72+
73+
t0 = System.currentTimeMillis();
74+
for (BigInteger testNum : testSet) {
75+
Roots.ithRoot_Heron2(testNum, root);
76+
}
77+
t1 = System.currentTimeMillis();
78+
LOG.info(" Heron2 ith root test with " + nCount + " numbers took " + (t1-t0) + " ms");
79+
}
80+
}
81+
}
82+
83+
/**
84+
* Test.
85+
* @param args ignored
86+
*/
87+
public static void main(String[] args) {
88+
ConfigUtil.initProject();
89+
testPerformance(5000000);
90+
}
91+
}

‎src/test/java/de/tilman_neumann/jml/roots/RootsTest.java

+116
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,116 @@
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.roots;
15+
16+
import java.math.BigInteger;
17+
import java.security.SecureRandom;
18+
19+
import org.apache.logging.log4j.Logger;
20+
import org.junit.Before;
21+
import org.junit.Test;
22+
import org.apache.logging.log4j.LogManager;
23+
24+
import de.tilman_neumann.util.ConfigUtil;
25+
26+
import static org.junit.Assert.assertEquals;
27+
28+
/**
29+
* Test i.th roots of integers.
30+
*
31+
* @author Tilman Neumann
32+
*/
33+
public class RootsTest {
34+
private static final Logger LOG = LogManager.getLogger(RootsTest.class);
35+
private static final SecureRandom RNG = new SecureRandom();
36+
37+
private static final int NCOUNT = 10000;
38+
private static final int MIN_BITS = 100;
39+
private static final int MAX_BITS = 1000;
40+
private static final int INCR_BITS = 100;
41+
42+
private BigInteger[][] testSets = new BigInteger[MAX_BITS + 1][];
43+
44+
private int[] roots = new int[NCOUNT];
45+
46+
@Before
47+
public void setup() {
48+
ConfigUtil.initProject();
49+
// create test sets
50+
for (int bits = MIN_BITS; bits<=MAX_BITS; bits+=INCR_BITS) {
51+
testSets[bits] = createTestSet(NCOUNT, bits);
52+
}
53+
// create roots
54+
for (int i=0; i<NCOUNT; i++) {
55+
roots[i] = 2 + RNG.nextInt(48);
56+
}
57+
}
58+
59+
/**
60+
* create test set for performance test: random ints with random bit length < 1000
61+
* @param nCount
62+
* @return
63+
*/
64+
private static BigInteger[] createTestSet(int nCount, int bits) {
65+
BigInteger[] testSet = new BigInteger[nCount];
66+
for (int i=0; i<nCount;) {
67+
BigInteger testNum = new BigInteger(bits, RNG);
68+
if (testNum.bitLength()<bits) continue; // not exact size, skip
69+
testSet[i] = testNum;
70+
i++;
71+
}
72+
return testSet;
73+
}
74+
75+
@Test
76+
public void testHeron1() {
77+
for (int bits = MIN_BITS; bits<=MAX_BITS; bits+=INCR_BITS) {
78+
BigInteger[] testSet = testSets[bits];
79+
for (int i=0; i<NCOUNT; i++) {
80+
BigInteger testNum = testSet[i];
81+
int root = roots[i];
82+
BigInteger[] linResult = Roots.ithRoot_bitwise(testNum, root);
83+
BigInteger[] heronResult = Roots.ithRoot_Heron1(testNum, root);
84+
if (!linResult[0].equals(heronResult[0])) {
85+
LOG.error("ERROR: Heron1: lower bound of " + root + ".th root(" + testNum + "): linear algorithm -> " + linResult[0] + ", Heron1 -> " + heronResult[0]);
86+
}
87+
assertEquals(linResult[0], heronResult[0]);
88+
if (!linResult[1].equals(heronResult[1])) {
89+
LOG.error("ERROR: Heron1: upper bound of " + root + ".th root(" + testNum + "): linear algorithm -> " + linResult[1] + ", Heron1 -> " + heronResult[1]);
90+
}
91+
assertEquals(linResult[1], heronResult[1]);
92+
}
93+
}
94+
}
95+
96+
@Test
97+
public void testHeron2() {
98+
for (int bits = MIN_BITS; bits<=MAX_BITS; bits+=INCR_BITS) {
99+
BigInteger[] testSet = testSets[bits];
100+
for (int i=0; i<NCOUNT; i++) {
101+
BigInteger testNum = testSet[i];
102+
int root = roots[i];
103+
BigInteger[] linResult = Roots.ithRoot_bitwise(testNum, root);
104+
BigInteger[] heronResult = Roots.ithRoot_Heron2(testNum, root);
105+
if (!linResult[0].equals(heronResult[0])) {
106+
LOG.error("ERROR: Heron2: lower bound of " + root + ".th root(" + testNum + "): linear algorithm -> " + linResult[0] + ", Heron2 -> " + heronResult[0]);
107+
}
108+
assertEquals(linResult[0], heronResult[0]);
109+
if (!linResult[1].equals(heronResult[1])) {
110+
LOG.error("ERROR: Heron2: upper bound of " + root + ".th root(" + testNum + "): linear algorithm -> " + linResult[1] + ", Heron2 -> " + heronResult[1]);
111+
}
112+
assertEquals(linResult[1], heronResult[1]);
113+
}
114+
}
115+
}
116+
}

0 commit comments

Comments
 (0)