Skip to content

Commit 0c115bd

Browse files
TilmanNeumannTilmanNeumann
committed
convert tests for BigInteger sqrt
1 parent b4156a6 commit 0c115bd

File tree

3 files changed

+158
-76
lines changed

3 files changed

+158
-76
lines changed

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

+6-76
Original file line numberDiff line numberDiff line change
@@ -16,14 +16,11 @@
1616
import static de.tilman_neumann.jml.base.BigIntConstants.*;
1717

1818
import java.math.BigInteger;
19-
import java.security.SecureRandom;
20-
import java.util.ArrayList;
2119

2220
import org.apache.logging.log4j.Logger;
2321
import org.apache.logging.log4j.LogManager;
2422

2523
import de.tilman_neumann.jml.base.BigIntConverter;
26-
import de.tilman_neumann.util.ConfigUtil;
2724

2825
/**
2926
* Fast sqrt() computation with integer solutions using Herons (or "Babylonian") method
@@ -33,7 +30,7 @@
3330
*/
3431
public class SqrtInt {
3532
private static final Logger LOG = LogManager.getLogger(SqrtInt.class);
36-
private static final SecureRandom RNG = new SecureRandom();
33+
private static final boolean DEBUG = false;
3734

3835
/**
3936
* sqrt() computation with integer solutions using Herons (or "Babylonian") method
@@ -57,20 +54,20 @@ public class SqrtInt {
5754
if ((shiftsRight & 1) == 1) shiftsRight++; // make even -> n looses 1 bit of precision
5855
double sqrt = Math.sqrt(N.shiftRight(shiftsRight).doubleValue());
5956
BigInteger initialGuess = BigIntConverter.fromDoubleMulPow2(sqrt, shiftsRight>>1);
60-
//LOG.debug(i + ".th root(" + N + "): initialGuess = " + initialGuess);
57+
if (DEBUG) LOG.debug("sqrt(" + N + "): initialGuess = " + initialGuess);
6158
return iSqrt(N, initialGuess);
6259
} else if (bits >= 127) {
6360
// N has 127..1023 bits -> the argument fits into double, no shifts required.
6461
// the result has 64..511 bits which means some Heron steps are required.
6562
BigInteger initialGuess = BigIntConverter.fromDouble(Math.sqrt(N.doubleValue()));
66-
//LOG.debug(i + ".th root(" + N + "): initialGuess = " + initialGuess);
63+
if (DEBUG) LOG.debug("sqrt(" + N + "): initialGuess = " + initialGuess);
6764
return iSqrt(N, initialGuess);
6865
} else if (bits >= 107) {
6966
// N has 107..126 bits -> too big to get around without Heron steps, but small enough to let
7067
// the resulting sqrt fit into long -> BigInteger construction is faster.
7168
// N with 127 bits should fit here too, but showed very bad performance.
7269
BigInteger initialGuess = BigInteger.valueOf( (long) Math.sqrt(N.doubleValue()));
73-
//LOG.debug(i + ".th root(" + N + "): initialGuess = " + initialGuess);
70+
if (DEBUG) LOG.debug("sqrt(" + N + "): initialGuess = " + initialGuess);
7471
return iSqrt(N, initialGuess);
7572
} else if (bits >= 64) {
7673
// N has 64...106 bits -> the resulting sqrt has a size of 32...53 bits and 52 bits (double) precision.
@@ -108,85 +105,18 @@ public class SqrtInt {
108105
public static BigInteger[] iSqrt(BigInteger n, BigInteger guess) {
109106
// do one approximation step before first convergence check
110107
guess = n.divide(guess).add(guess).shiftRight(1);
111-
//LOG.debug("initial guess: sqrt(" + n + ") ~ " + guess);
108+
if (DEBUG) LOG.debug("initial guess: sqrt(" + n + ") ~ " + guess);
112109

113110
BigInteger lastGuess;
114111
do {
115112
lastGuess = guess;
116113
guess = n.divide(guess).add(guess).shiftRight(1);
117-
//LOG.debug("next guess: sqrt(" + n + ") ~ " + guess);
114+
if (DEBUG) LOG.debug("next guess: sqrt(" + n + ") ~ " + guess);
118115
} while (guess.subtract(lastGuess).abs().bitLength()>1); // while absolute difference > 1
119116

120117
int cmp = guess.multiply(guess).compareTo(n);
121118
if (cmp < 0) return new BigInteger[] {guess, guess.add(I_1)};
122119
if (cmp > 0) return new BigInteger[] {guess.subtract(I_1), guess};
123120
return new BigInteger[] {guess, guess}; // exact sqrt()
124121
}
125-
126-
// test -----------------------------------------------------------
127-
128-
/**
129-
* create test set for performance test: random ints with random bit length < 1000
130-
* @param nCount
131-
* @return
132-
*/
133-
private static ArrayList<BigInteger> createTestSet(int nCount, int bits) {
134-
ArrayList<BigInteger> testSet = new ArrayList<BigInteger>();
135-
for (int i=0; i<nCount;) {
136-
BigInteger testNum = new BigInteger(bits, RNG);
137-
if (testNum.bitLength()<bits) continue; // not exact size, skip
138-
testSet.add(testNum);
139-
i++;
140-
}
141-
return testSet;
142-
}
143-
144-
private static void testCorrectness(int nCount) {
145-
for (int bits = 100; bits<=130; bits+=1) {
146-
LOG.info("test correctness of sqrt() implementations for " + bits + "-bit numbers...");
147-
ArrayList<BigInteger> testSet = createTestSet(nCount, bits);
148-
for (BigInteger testNum : testSet) {
149-
testCorrectness(testNum, bits, iSqrt/*_v01*/(testNum), "v01");
150-
}
151-
}
152-
}
153-
154-
private static void testCorrectness(BigInteger testNum, int bits, BigInteger[] result, String algStr) {
155-
BigInteger lower = result[0];
156-
BigInteger lowerSquare = lower.multiply(lower);
157-
if (lowerSquare.compareTo(testNum) > 0) LOG.error(algStr + ": ERROR at " + bits + " bits: lower bound of sqrt(" + testNum + ") = " + lower + " is too big");
158-
BigInteger upper = result[1];
159-
BigInteger upperSquare = upper.multiply(upper);
160-
if (upperSquare.compareTo(testNum) < 0) LOG.error(algStr + ": ERROR at " + bits + " bits: upper bound of sqrt(" + testNum + ") = " + upper + " is too small");
161-
162-
if (lowerSquare.equals(testNum) || upperSquare.equals(testNum)) {
163-
if (!lower.equals(upper)) LOG.error(algStr + ": ERROR at " + bits + " bits: sqrt(" + testNum + ") is exact, but the computed bounds = [" + lower + ", " + upper + "] are different!");
164-
} else {
165-
if (upper.subtract(lower).compareTo(I_1)>0) LOG.error(algStr + ": ERROR at " + bits + " bits: lower and upper bound of sqrt(" + testNum + ") = [" + lower + ", " + upper + "] differ by more than 1");
166-
}
167-
}
168-
169-
private static void testPerformance(int nCount) {
170-
for (int bits = 10; ; bits += 10 /*RNG.nextInt(50)*/) {
171-
ArrayList<BigInteger> testSet = createTestSet(nCount, bits);
172-
LOG.info("test sqrt of " + bits + "-bit numbers:");
173-
long t0, t1;
174-
t0 = System.currentTimeMillis();
175-
for (BigInteger testNum : testSet) {
176-
iSqrt/*_v01*/(testNum);
177-
}
178-
t1 = System.currentTimeMillis();
179-
LOG.info(" v01 sqrt with " + nCount + " numbers took " + (t1-t0) + " ms");
180-
}
181-
}
182-
183-
/**
184-
* Test.
185-
* @param args ignored
186-
*/
187-
public static void main(String[] args) {
188-
ConfigUtil.initProject();
189-
testCorrectness(100000);
190-
testPerformance(1000000);
191-
}
192122
}

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

+72
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
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+
import java.util.ArrayList;
19+
20+
import org.apache.logging.log4j.Logger;
21+
import org.apache.logging.log4j.LogManager;
22+
23+
import de.tilman_neumann.util.ConfigUtil;
24+
25+
/**
26+
* Performance test for sqrt() computation with integer solutions.
27+
*
28+
* @author Tilman Neumann
29+
*/
30+
public class SqrtIntPerformanceTest {
31+
private static final Logger LOG = LogManager.getLogger(SqrtIntPerformanceTest.class);
32+
private static final SecureRandom RNG = new SecureRandom();
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 ArrayList<BigInteger> createTestSet(int nCount, int bits) {
40+
ArrayList<BigInteger> testSet = new ArrayList<BigInteger>();
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.add(testNum);
45+
i++;
46+
}
47+
return testSet;
48+
}
49+
50+
private static void testPerformance(int nCount) {
51+
for (int bits = 10; ; bits += 10) {
52+
ArrayList<BigInteger> testSet = createTestSet(nCount, bits);
53+
LOG.info("test sqrt of " + bits + "-bit numbers:");
54+
long t0, t1;
55+
t0 = System.currentTimeMillis();
56+
for (BigInteger testNum : testSet) {
57+
SqrtInt.iSqrt/*_v01*/(testNum);
58+
}
59+
t1 = System.currentTimeMillis();
60+
LOG.info(" v01 sqrt with " + nCount + " numbers took " + (t1-t0) + " ms");
61+
}
62+
}
63+
64+
/**
65+
* Test.
66+
* @param args ignored
67+
*/
68+
public static void main(String[] args) {
69+
ConfigUtil.initProject();
70+
testPerformance(1000000);
71+
}
72+
}

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

+80
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,80 @@
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 static de.tilman_neumann.jml.base.BigIntConstants.*;
17+
import static org.junit.Assert.assertEquals;
18+
19+
import java.math.BigInteger;
20+
import java.security.SecureRandom;
21+
import java.util.ArrayList;
22+
23+
import org.apache.logging.log4j.Logger;
24+
import org.junit.Test;
25+
import org.apache.logging.log4j.LogManager;
26+
27+
/**
28+
* Test sqrt() computation with integer solutions.
29+
*
30+
* @author Tilman Neumann
31+
*/
32+
public class SqrtIntTest {
33+
private static final Logger LOG = LogManager.getLogger(SqrtIntTest.class);
34+
private static final SecureRandom RNG = new SecureRandom();
35+
private static final int NCOUNT = 10000;
36+
37+
/**
38+
* create test set for performance test: random ints with random bit length < 1000
39+
* @param nCount
40+
* @return
41+
*/
42+
private static ArrayList<BigInteger> createTestSet(int nCount, int bits) {
43+
ArrayList<BigInteger> testSet = new ArrayList<BigInteger>();
44+
for (int i=0; i<nCount;) {
45+
BigInteger testNum = new BigInteger(bits, RNG);
46+
if (testNum.bitLength()<bits) continue; // not exact size, skip
47+
testSet.add(testNum);
48+
i++;
49+
}
50+
return testSet;
51+
}
52+
53+
@Test
54+
public void testCorrectness() {
55+
for (int bits = 10; bits<=1000; bits+=10) {
56+
LOG.info("test correctness of sqrt() implementations for " + bits + "-bit numbers...");
57+
ArrayList<BigInteger> testSet = createTestSet(NCOUNT, bits);
58+
for (BigInteger testNum : testSet) {
59+
testCorrectness(testNum, bits, SqrtInt.iSqrt/*_v01*/(testNum), "v01");
60+
}
61+
}
62+
}
63+
64+
private static void testCorrectness(BigInteger testNum, int bits, BigInteger[] result, String algStr) {
65+
BigInteger lower = result[0];
66+
BigInteger lowerSquare = lower.multiply(lower);
67+
if (lowerSquare.compareTo(testNum) > 0) LOG.error(algStr + ": ERROR at " + bits + " bits: lower bound of sqrt(" + testNum + ") = " + lower + " is too big");
68+
BigInteger upper = result[1];
69+
BigInteger upperSquare = upper.multiply(upper);
70+
if (upperSquare.compareTo(testNum) < 0) LOG.error(algStr + ": ERROR at " + bits + " bits: upper bound of sqrt(" + testNum + ") = " + upper + " is too small");
71+
72+
if (lowerSquare.equals(testNum) || upperSquare.equals(testNum)) {
73+
if (!lower.equals(upper)) LOG.error(algStr + ": ERROR at " + bits + " bits: sqrt(" + testNum + ") is exact, but the computed bounds = [" + lower + ", " + upper + "] are different!");
74+
assertEquals(lower, upper);
75+
} else {
76+
if (upper.subtract(lower).compareTo(I_1)>0) LOG.error(algStr + ": ERROR at " + bits + " bits: lower and upper bound of sqrt(" + testNum + ") = [" + lower + ", " + upper + "] differ by more than 1");
77+
assertEquals(upper.subtract(lower), I_1);
78+
}
79+
}
80+
}

0 commit comments

Comments
 (0)