Skip to content

Commit 6b85bfe

Browse files
TilmanNeumannTilmanNeumann
committed
unit test for Jacobi and Legendre symbol
1 parent 0def781 commit 6b85bfe

File tree

2 files changed

+171
-77
lines changed

2 files changed

+171
-77
lines changed

‎src/main/java/de/tilman_neumann/jml/modular/JacobiTest.java ‎src/test/java/de/tilman_neumann/jml/modular/JacobiSymbolPerformanceTest.java

+7-77
Original file line numberDiff line numberDiff line change
@@ -16,112 +16,43 @@
1616
import java.math.BigInteger;
1717
import java.security.SecureRandom;
1818
import java.util.ArrayList;
19-
import java.util.Iterator;
2019

2120
import org.apache.logging.log4j.Logger;
2221
import org.apache.logging.log4j.LogManager;
2322

2423
import de.tilman_neumann.jml.primes.probable.BPSWTest;
25-
import de.tilman_neumann.util.Ensure;
2624
import de.tilman_neumann.util.ConfigUtil;
2725

2826
import static de.tilman_neumann.jml.base.BigIntConstants.*;
2927

3028
/**
31-
* Test of Legendre and Jacobi symbol.
29+
* Performance test of Legendre and Jacobi symbol.
3230
*
33-
* Result: Jacobi is always faster than Eulers formula!
31+
* Result: Jacobi is always faster than Eulers formula.
3432
*
3533
* @author Tilman Neumann
3634
*/
37-
public class JacobiTest {
38-
private static final Logger LOG = LogManager.getLogger(JacobiTest.class);
35+
public class JacobiSymbolPerformanceTest {
36+
private static final Logger LOG = LogManager.getLogger(JacobiSymbolPerformanceTest.class);
3937
private static final boolean TEST_SLOW = false;
4038

41-
private static final int NCOUNT_CORRECTNESS = 200;
42-
private static final int NCOUNT_PERFORMANCE = 1000;
39+
private static final int NCOUNT = 1000;
4340
private static final int MAX_BITS = 500;
4441

4542
private static final BPSWTest bpsw = new BPSWTest();
4643

47-
private static void testCorrectness() {
48-
LegendreSymbol legendreEngine = new LegendreSymbol();
49-
JacobiSymbol jacobiEngine = new JacobiSymbol();
50-
SecureRandom rng = new SecureRandom();
51-
ArrayList<Integer> aList_int=null, pList_int=null;
52-
for (int bits=10; bits<100; bits+=10) {
53-
// generate test numbers
54-
ArrayList<BigInteger> aList = new ArrayList<BigInteger>();
55-
ArrayList<BigInteger> pList = new ArrayList<BigInteger>();
56-
for (int i=0; i<NCOUNT_CORRECTNESS; i++) {
57-
aList.add(new BigInteger(bits, rng));
58-
}
59-
int i=0;
60-
while (i<NCOUNT_CORRECTNESS) {
61-
// the p must be odd, and to allow comparison with the Legendre symbol it should be odd primes
62-
BigInteger p = bpsw.nextProbablePrime(new BigInteger(bits, rng));
63-
if (p.and(I_1).intValue()==1) {
64-
pList.add(p);
65-
i++;
66-
}
67-
}
68-
69-
if (bits <31) {
70-
aList_int = new ArrayList<Integer>();
71-
for (BigInteger a : aList) aList_int.add(a.intValue());
72-
pList_int = new ArrayList<Integer>();
73-
for (BigInteger p : pList) pList_int.add(p.intValue());
74-
}
75-
76-
LOG.info("test Legendre(a|p) and Jacobi(a|p) for test numbers with " + bits + " bits");
77-
78-
Iterator<Integer> aIntIter = aList_int.iterator();
79-
for (BigInteger a : aList) {
80-
int aInt = aIntIter.next();
81-
Iterator<Integer> pIntIter = pList_int.iterator();
82-
for (BigInteger p : pList) {
83-
int pInt = pIntIter.next();
84-
// test big argument formulas
85-
int correct = jacobiEngine.jacobiSymbol_v01(a, p);
86-
int jacobi02 = jacobiEngine.jacobiSymbol_v02(a, p);
87-
int jacobi03 = jacobiEngine.jacobiSymbol/*_v03*/(a, p);
88-
int legendre = legendreEngine.EulerFormula(a, p);
89-
Ensure.ensureEquals(correct, jacobi02);
90-
Ensure.ensureEquals(correct, jacobi03);
91-
Ensure.ensureEquals(correct, legendre);
92-
// test formulas with big a, int p (p and pInt will be different for bits>30)
93-
correct = jacobiEngine.jacobiSymbol_v01(a, BigInteger.valueOf(pInt));
94-
jacobi03 = jacobiEngine.jacobiSymbol/*_v03*/(a, pInt);
95-
legendre = legendreEngine.EulerFormula(a, pInt);
96-
Ensure.ensureEquals(correct, jacobi03);
97-
Ensure.ensureEquals(correct, legendre);
98-
// test formulas with int a, big p (a and aInt will be different for bits>30)
99-
correct = jacobiEngine.jacobiSymbol_v01(BigInteger.valueOf(aInt), p);
100-
jacobi03 = jacobiEngine.jacobiSymbol/*_v03*/(aInt, p);
101-
Ensure.ensureEquals(correct, jacobi03);
102-
// test formulas with all int arguments (a, aInt will differ as well as p, pInt for bits>30)
103-
correct = jacobiEngine.jacobiSymbol_v01(BigInteger.valueOf(aInt), BigInteger.valueOf(pInt));
104-
jacobi03 = jacobiEngine.jacobiSymbol/*_v03*/(aInt, pInt);
105-
legendre = legendreEngine.EulerFormula(aInt, pInt);
106-
Ensure.ensureEquals(correct, jacobi03);
107-
Ensure.ensureEquals(correct, legendre);
108-
}
109-
}
110-
}
111-
}
112-
11344
private static void testPerformance() {
11445
SecureRandom rng = new SecureRandom();
11546
ArrayList<Integer> aList_int=null, pList_int=null;
11647
for (int bits=10; bits<MAX_BITS; bits+=10) {
11748
// generate test numbers
11849
ArrayList<BigInteger> aList = new ArrayList<BigInteger>();
11950
ArrayList<BigInteger> pList = new ArrayList<BigInteger>();
120-
for (int i=0; i<NCOUNT_PERFORMANCE; i++) {
51+
for (int i=0; i<NCOUNT; i++) {
12152
aList.add(new BigInteger(bits, rng));
12253
}
12354
int i=0;
124-
while (i<NCOUNT_PERFORMANCE) {
55+
while (i<NCOUNT) {
12556
// the p must be odd, and to allow comparison with the Legendre symbol it should be odd primes
12657
BigInteger p = bpsw.nextProbablePrime(new BigInteger(bits, rng));
12758
if (p.and(I_1).intValue()==1) {
@@ -225,7 +156,6 @@ private static void testPerformance() {
225156
*/
226157
public static void main(String[] args) {
227158
ConfigUtil.initProject();
228-
testCorrectness();
229159
testPerformance();
230160
}
231161
}

‎src/test/java/de/tilman_neumann/jml/modular/JacobiSymbolTest.java

+164
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,164 @@
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.modular;
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.junit.BeforeClass;
22+
import org.junit.Test;
23+
import org.apache.logging.log4j.LogManager;
24+
25+
import de.tilman_neumann.jml.primes.probable.BPSWTest;
26+
import de.tilman_neumann.util.ConfigUtil;
27+
28+
import static de.tilman_neumann.jml.base.BigIntConstants.*;
29+
import static org.junit.Assert.assertEquals;
30+
31+
/**
32+
* Test of Legendre and Jacobi symbol.
33+
*
34+
* @author Tilman Neumann
35+
*/
36+
public class JacobiSymbolTest {
37+
private static final Logger LOG = LogManager.getLogger(JacobiSymbolTest.class);
38+
39+
private static final int NCOUNT = 200;
40+
private static final int MAX_BITS = 100;
41+
42+
private static final BPSWTest bpsw = new BPSWTest();
43+
private static final SecureRandom rng = new SecureRandom();
44+
private static final LegendreSymbol legendreEngine = new LegendreSymbol();
45+
private static final JacobiSymbol jacobiEngine = new JacobiSymbol();;
46+
47+
@SuppressWarnings("unchecked")
48+
private static ArrayList<BigInteger>[] aListsForBitSize = new ArrayList[MAX_BITS];
49+
@SuppressWarnings("unchecked")
50+
private static ArrayList<BigInteger>[] pListsForBitSize = new ArrayList[MAX_BITS];
51+
52+
@BeforeClass
53+
public static void setup() {
54+
ConfigUtil.initProject();
55+
56+
// generate test numbers
57+
for (int bits=10; bits<MAX_BITS; bits+=10) {
58+
ArrayList<BigInteger> aList = new ArrayList<BigInteger>();
59+
for (int i=0; i<NCOUNT; i++) {
60+
aList.add(new BigInteger(bits, rng));
61+
}
62+
aListsForBitSize[bits] = aList;
63+
64+
int i=0;
65+
ArrayList<BigInteger> pList = new ArrayList<BigInteger>();
66+
while (i<NCOUNT) {
67+
// the p must be odd, and to allow comparison with the Legendre symbol it should be odd primes
68+
BigInteger p = bpsw.nextProbablePrime(new BigInteger(bits, rng));
69+
if (p.and(I_1).intValue()==1) {
70+
pList.add(p);
71+
i++;
72+
}
73+
}
74+
pListsForBitSize[bits] = pList;
75+
}
76+
}
77+
78+
@Test
79+
public void testBigABigP() {
80+
for (int bits=10; bits<MAX_BITS; bits+=10) {
81+
ArrayList<BigInteger> aList = aListsForBitSize[bits];
82+
ArrayList<BigInteger> pList = pListsForBitSize[bits];
83+
84+
LOG.info("test Legendre(a|p) and Jacobi(a|p) for BigInteger a, p with " + bits + " bit.");
85+
86+
for (BigInteger a : aList) {
87+
for (BigInteger p : pList) {
88+
int correct = jacobiEngine.jacobiSymbol_v01(a, p);
89+
int jacobi02 = jacobiEngine.jacobiSymbol_v02(a, p);
90+
int jacobi03 = jacobiEngine.jacobiSymbol/*_v03*/(a, p);
91+
int legendre = legendreEngine.EulerFormula(a, p);
92+
assertEquals(correct, jacobi02);
93+
assertEquals(correct, jacobi03);
94+
assertEquals(correct, legendre);
95+
}
96+
}
97+
}
98+
}
99+
100+
@Test
101+
public void testBigASmallP() {
102+
for (int bits=10; bits<MAX_BITS; bits+=10) {
103+
ArrayList<BigInteger> aList = aListsForBitSize[bits];
104+
int pBits = Math.min(bits, 30);
105+
ArrayList<BigInteger> pList = pListsForBitSize[pBits];
106+
107+
LOG.info("test Legendre(a|p) and Jacobi(a|p) for BigInteger a with " + bits + " bit and int p with " + pBits + " bit.");
108+
109+
for (BigInteger a : aList) {
110+
for (BigInteger p : pList) {
111+
int pInt = p.intValue();
112+
int correct = jacobiEngine.jacobiSymbol_v01(a, p);
113+
int jacobi03 = jacobiEngine.jacobiSymbol/*_v03*/(a, pInt);
114+
int legendre = legendreEngine.EulerFormula(a, pInt);
115+
assertEquals(correct, jacobi03);
116+
assertEquals(correct, legendre);
117+
}
118+
}
119+
}
120+
}
121+
122+
@Test
123+
public void testSmallABigP() {
124+
// we have no Euler formula implementation with small a and big p, so here only Jacobi is tested
125+
for (int bits=10; bits<MAX_BITS; bits+=10) {
126+
int aBits = Math.min(bits, 30);
127+
ArrayList<BigInteger> aList = aListsForBitSize[aBits];
128+
ArrayList<BigInteger> pList = pListsForBitSize[bits];
129+
130+
LOG.info("test Jacobi(a|p) for int a with " + aBits + " bit and BigInteger p with " + bits + " bit.");
131+
132+
for (BigInteger a : aList) {
133+
int aInt = a.intValue();
134+
for (BigInteger p : pList) {
135+
int correct = jacobiEngine.jacobiSymbol_v01(a, p);
136+
int jacobi03 = jacobiEngine.jacobiSymbol/*_v03*/(aInt, p);
137+
assertEquals(correct, jacobi03);
138+
}
139+
}
140+
}
141+
}
142+
143+
@Test
144+
public void testSmallASmallP() {
145+
for (int bits=10; bits<=30; bits+=10) {
146+
ArrayList<BigInteger> aList = aListsForBitSize[bits];
147+
ArrayList<BigInteger> pList = pListsForBitSize[bits];
148+
149+
LOG.info("test Legendre(a|p) and Jacobi(a|p) for int a, p with " + bits + " bits");
150+
151+
for (BigInteger a : aList) {
152+
int aInt = a.intValue();
153+
for (BigInteger p : pList) {
154+
int pInt = p.intValue();
155+
int correct = jacobiEngine.jacobiSymbol_v01(a, p);
156+
int jacobi03 = jacobiEngine.jacobiSymbol/*_v03*/(aInt, pInt);
157+
int legendre = legendreEngine.EulerFormula(aInt, pInt);
158+
assertEquals(correct, jacobi03);
159+
assertEquals(correct, legendre);
160+
}
161+
}
162+
}
163+
}
164+
}

0 commit comments

Comments
 (0)