Skip to content

Commit bb7ac05

Browse files
TilmanNeumannTilmanNeumann
committed
move analyzer classes to test scope
1 parent a7cd1de commit bb7ac05

4 files changed

+133
-66
lines changed

‎src/main/java/de/tilman_neumann/jml/primes/PrimeCountsBetweenSquares.java ‎src/test/java/de/tilman_neumann/jml/primes/PrimeCountsBetweenSquaresAnalyzer.java

+4-4
Original file line numberDiff line numberDiff line change
@@ -25,8 +25,8 @@
2525
*
2626
* @author Tilman Neumann
2727
*/
28-
public class PrimeCountsBetweenSquares implements SieveCallback {
29-
private static final Logger LOG = LogManager.getLogger(PrimeCountsBetweenSquares.class);
28+
public class PrimeCountsBetweenSquaresAnalyzer implements SieveCallback {
29+
private static final Logger LOG = LogManager.getLogger(PrimeCountsBetweenSquaresAnalyzer.class);
3030

3131
private SegmentedSieve sieve;
3232
private long limit;
@@ -38,7 +38,7 @@ public class PrimeCountsBetweenSquares implements SieveCallback {
3838
private long s1;
3939

4040

41-
public PrimeCountsBetweenSquares(long limit) {
41+
public PrimeCountsBetweenSquaresAnalyzer(long limit) {
4242
sieve = new SegmentedSieve(this);
4343
this.limit = limit;
4444
}
@@ -67,7 +67,7 @@ public void processPrime(long prime) {
6767

6868
public static void main(String[] args) {
6969
ConfigUtil.initProject();
70-
new PrimeCountsBetweenSquares(100000000000L).run();
70+
new PrimeCountsBetweenSquaresAnalyzer(100000000000L).run();
7171
// result: A014085 = 2, 2, 2, 3, 2, 4, 3, 4, 3, 5, 4, 5, 5, 4, 6, 7, 5, 6, 6, 7, 7, 7, ...
7272
// In that entry we also see that a stronger conjecture exists:
7373
// There is at least one prime in n^k...n^(k+1) with k = log(127)/log(16) ~ 1.747171172

‎src/main/java/de/tilman_neumann/jml/primes/PrimeGapTest.java ‎src/test/java/de/tilman_neumann/jml/primes/PrimeGapAnalyzer.java

+4-4
Original file line numberDiff line numberDiff line change
@@ -44,8 +44,8 @@
4444
*
4545
* @author Tilman Neumann
4646
*/
47-
public class PrimeGapTest implements SieveCallback {
48-
private static final Logger LOG = LogManager.getLogger(PrimeGapTest.class);
47+
public class PrimeGapAnalyzer implements SieveCallback {
48+
private static final Logger LOG = LogManager.getLogger(PrimeGapAnalyzer.class);
4949

5050
public static class StackElement {
5151
public long lastPrime;
@@ -66,7 +66,7 @@ public StackElement(long lastPrime, long prime, double ratio) {
6666
private long lastPrime = 2; // avoid "simulated" large relative prime gap
6767
private int highestRankUpdate = Integer.MAX_VALUE;
6868

69-
public PrimeGapTest(long limit) {
69+
public PrimeGapAnalyzer(long limit) {
7070
stack = new Stack<StackElement>();
7171
sieve = new SegmentedSieve(this);
7272
this.limit = limit;
@@ -178,6 +178,6 @@ private void checkResult(StackElement elem, int i) {
178178

179179
public static void main(String[] args) {
180180
ConfigUtil.initProject();
181-
new PrimeGapTest(100000000000L).run();
181+
new PrimeGapAnalyzer(100000000000L).run();
182182
}
183183
}

‎src/main/java/de/tilman_neumann/jml/primes/RiemannHypothesisTest.java ‎src/test/java/de/tilman_neumann/jml/primes/RiemannLagariasHypothesisAnalyzer.java

+3-58
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,6 @@
2727
import de.tilman_neumann.jml.precision.Scale;
2828
import de.tilman_neumann.jml.smooth.CANEntry;
2929
import de.tilman_neumann.jml.smooth.CANIterator;
30-
import de.tilman_neumann.jml.transcendental.EulerConstant;
3130
import de.tilman_neumann.jml.transcendental.Exp;
3231
import de.tilman_neumann.jml.transcendental.Ln;
3332
import de.tilman_neumann.jml.HarmonicNumbers;
@@ -39,7 +38,7 @@
3938
import static de.tilman_neumann.jml.base.BigDecimalConstants.F_0;
4039

4140
/**
42-
* Tests Robins and Lagarias' Riemann hypothesis tests on colossally abundant numbers (CANs).
41+
* Tests Lagarias' Riemann hypothesis on colossally abundant numbers (CANs).
4342
*
4443
* From page 4 of http://www.math.lsa.umich.edu/~lagarias/doc/elementaryrh.pdf:
4544
* "Robin showed that, if the Riemann hypothesis is false, then there will necessarily exist a counterexample
@@ -49,65 +48,12 @@
4948
*
5049
* Inequality (1.2) (Robin): sigma(n) <= exp(gamma) n ln(ln(n)) for each n >=5041
5150
*/
52-
public class RiemannHypothesisTest {
53-
private static final Logger LOG = LogManager.getLogger(RiemannHypothesisTest.class);
51+
public class RiemannLagariasHypothesisAnalyzer {
52+
private static final Logger LOG = LogManager.getLogger(RiemannLagariasHypothesisAnalyzer.class);
5453

5554
private static final boolean DEBUG = false;
5655

5756
private static final Timer timer = new Timer();
58-
59-
/**
60-
* Test inequality (1.2) with CANs.
61-
*
62-
* >24k CANs checked. Typical timings:
63-
* Tested CAN(24003) with 118278 digits... t0=2297, t1=16, t2=0, t3=0, t4=16, t5=281
64-
* Tested CAN(24004) with 118284 digits... t0=0, t1=26, t2=0, t3=0, t4=0, t5=297
65-
* Tested CAN(24005) with 118289 digits... t0=1735, t1=15, t2=0, t3=0, t4=16, t5=281
66-
* Tested CAN(24006) with 118295 digits... t0=0, t1=18, t2=0, t3=0, t4=0, t5=313
67-
* Tested CAN(24007) with 118300 digits... t0=1187, t1=31, t2=0, t3=0, t4=0, t5=282
68-
* Tested CAN(24008) with 118306 digits... t0=0, t1=18, t2=0, t3=0, t4=0, t5=297
69-
* Tested CAN(24009) with 118311 digits... t0=1703, t1=32, t2=0, t3=0, t4=0, t5=296
70-
* Tested CAN(24010) with 118314 digits... t0=0, t1=30, t2=0, t3=0, t4=0, t5=297
71-
* Tested CAN(24011) with 118319 digits... t0=609, t1=16, t2=0, t3=0, t4=15, t5=282
72-
* Tested CAN(24012) with 118325 digits... t0=0, t1=24, t2=0, t3=0, t4=0, t5=297
73-
*/
74-
private static void runRobinsRHTest() {
75-
long t0, t1, t2, t3, t4;
76-
77-
Scale scale = Scale.valueOf(30); // precision in after-floating point decimal digits
78-
BigDecimal expGamma = Exp.exp(EulerConstant.gamma(scale), scale);
79-
80-
CANIterator canIter = new CANIterator();
81-
for (int m=1; ; m++) {
82-
timer.capture();
83-
CANEntry canEntry = canIter.next();
84-
BigInteger n = canEntry.getCAN();
85-
t0 = timer.capture();
86-
87-
BigDecimal n_flt = new BigDecimal(n, 0);
88-
BigDecimal lnln_n = Ln.ln(Ln.ln(n_flt, scale), scale);
89-
t1 = timer.capture();
90-
91-
BigDecimal robin = expGamma.multiply(n_flt).multiply(lnln_n);
92-
t2 = timer.capture();
93-
94-
// Fast sumOfDivisors computation with known prime factorization
95-
SortedMultiset<BigInteger> factors = toSortedMultiset(canEntry.getPrimes(), canEntry.getExponents());
96-
t3 = timer.capture();
97-
if (DEBUG) LOG.debug("factors(n)=" + factors);
98-
BigInteger sigma = Divisors.sumOfDivisors(factors);
99-
BigDecimal diff = BigDecimalMath.subtract(robin, sigma);
100-
t4 = timer.capture();
101-
if (DEBUG) LOG.debug("sigma(n)=" + sigma + ", robin=" + robin + ", diff=" + diff);
102-
if (diff.compareTo(F_0) < 0) {
103-
LOG.info("Found RH counterexample candidate!");
104-
LOG.info(" m=" + m + ": n has " + Magnitude.of(n) + " digits");
105-
LOG.info(" n=" + n);
106-
} else {
107-
LOG.info("Tested CAN(" + m + ") with " + Magnitude.of(n) + " digits... t0=" + t0 + ", t1=" + t1 + ", t2=" + t2 + ", t3=" + t3 + ", t4=" + t4);
108-
}
109-
}
110-
}
11157

11258
/**
11359
* Test inequality (1.1) with CANs.
@@ -190,6 +136,5 @@ private static SortedMultiset<BigInteger> toSortedMultiset(ArrayList<BigInteger>
190136
public static void main(String[] argv) {
191137
ConfigUtil.initProject();
192138
runLagariasRHTest();
193-
//runRobinsRHTest();
194139
}
195140
}

‎src/test/java/de/tilman_neumann/jml/primes/RiemannRobinHypothesisAnalyzer.java

+122
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,122 @@
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.primes;
15+
16+
import java.math.BigDecimal;
17+
import java.math.BigInteger;
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.jml.Divisors;
24+
import de.tilman_neumann.jml.base.BigDecimalMath;
25+
import de.tilman_neumann.jml.precision.Magnitude;
26+
import de.tilman_neumann.jml.precision.Scale;
27+
import de.tilman_neumann.jml.smooth.CANEntry;
28+
import de.tilman_neumann.jml.smooth.CANIterator;
29+
import de.tilman_neumann.jml.transcendental.EulerConstant;
30+
import de.tilman_neumann.jml.transcendental.Exp;
31+
import de.tilman_neumann.jml.transcendental.Ln;
32+
import de.tilman_neumann.util.ConfigUtil;
33+
import de.tilman_neumann.util.SortedMultiset;
34+
import de.tilman_neumann.util.SortedMultiset_BottomUp;
35+
import de.tilman_neumann.util.Timer;
36+
37+
import static de.tilman_neumann.jml.base.BigDecimalConstants.F_0;
38+
39+
/**
40+
* Tests Robin's Riemann hypothesis tests on colossally abundant numbers (CANs).
41+
*
42+
* From page 4 of http://www.math.lsa.umich.edu/~lagarias/doc/elementaryrh.pdf:
43+
* "Robin showed that, if the Riemann hypothesis is false, then there will necessarily exist a counterexample
44+
* to the inequality (1.2) that is a colossally abundant number; the same property can be established for inequality (1.1)"
45+
*
46+
* Inequality (1.1) (Lagarias): sigma(n) <= Hn + exp(Hn)*ln(Hn)
47+
*
48+
* Inequality (1.2) (Robin): sigma(n) <= exp(gamma) n ln(ln(n)) for each n >=5041
49+
*/
50+
public class RiemannRobinHypothesisAnalyzer {
51+
private static final Logger LOG = LogManager.getLogger(RiemannRobinHypothesisAnalyzer.class);
52+
53+
private static final boolean DEBUG = false;
54+
55+
private static final Timer timer = new Timer();
56+
57+
/**
58+
* Test inequality (1.2) with CANs.
59+
*
60+
* >24k CANs checked. Typical timings:
61+
* Tested CAN(24003) with 118278 digits... t0=2297, t1=16, t2=0, t3=0, t4=16, t5=281
62+
* Tested CAN(24004) with 118284 digits... t0=0, t1=26, t2=0, t3=0, t4=0, t5=297
63+
* Tested CAN(24005) with 118289 digits... t0=1735, t1=15, t2=0, t3=0, t4=16, t5=281
64+
* Tested CAN(24006) with 118295 digits... t0=0, t1=18, t2=0, t3=0, t4=0, t5=313
65+
* Tested CAN(24007) with 118300 digits... t0=1187, t1=31, t2=0, t3=0, t4=0, t5=282
66+
* Tested CAN(24008) with 118306 digits... t0=0, t1=18, t2=0, t3=0, t4=0, t5=297
67+
* Tested CAN(24009) with 118311 digits... t0=1703, t1=32, t2=0, t3=0, t4=0, t5=296
68+
* Tested CAN(24010) with 118314 digits... t0=0, t1=30, t2=0, t3=0, t4=0, t5=297
69+
* Tested CAN(24011) with 118319 digits... t0=609, t1=16, t2=0, t3=0, t4=15, t5=282
70+
* Tested CAN(24012) with 118325 digits... t0=0, t1=24, t2=0, t3=0, t4=0, t5=297
71+
*/
72+
private static void runRobinsRHTest() {
73+
long t0, t1, t2, t3, t4;
74+
75+
Scale scale = Scale.valueOf(30); // precision in after-floating point decimal digits
76+
BigDecimal expGamma = Exp.exp(EulerConstant.gamma(scale), scale);
77+
78+
CANIterator canIter = new CANIterator();
79+
for (int m=1; ; m++) {
80+
timer.capture();
81+
CANEntry canEntry = canIter.next();
82+
BigInteger n = canEntry.getCAN();
83+
t0 = timer.capture();
84+
85+
BigDecimal n_flt = new BigDecimal(n, 0);
86+
BigDecimal lnln_n = Ln.ln(Ln.ln(n_flt, scale), scale);
87+
t1 = timer.capture();
88+
89+
BigDecimal robin = expGamma.multiply(n_flt).multiply(lnln_n);
90+
t2 = timer.capture();
91+
92+
// Fast sumOfDivisors computation with known prime factorization
93+
SortedMultiset<BigInteger> factors = toSortedMultiset(canEntry.getPrimes(), canEntry.getExponents());
94+
t3 = timer.capture();
95+
if (DEBUG) LOG.debug("factors(n)=" + factors);
96+
BigInteger sigma = Divisors.sumOfDivisors(factors);
97+
BigDecimal diff = BigDecimalMath.subtract(robin, sigma);
98+
t4 = timer.capture();
99+
if (DEBUG) LOG.debug("sigma(n)=" + sigma + ", robin=" + robin + ", diff=" + diff);
100+
if (diff.compareTo(F_0) < 0) {
101+
LOG.info("Found RH counterexample candidate!");
102+
LOG.info(" m=" + m + ": n has " + Magnitude.of(n) + " digits");
103+
LOG.info(" n=" + n);
104+
} else {
105+
LOG.info("Tested CAN(" + m + ") with " + Magnitude.of(n) + " digits... t0=" + t0 + ", t1=" + t1 + ", t2=" + t2 + ", t3=" + t3 + ", t4=" + t4);
106+
}
107+
}
108+
}
109+
110+
private static SortedMultiset<BigInteger> toSortedMultiset(ArrayList<BigInteger> primes, ArrayList<Integer> exponents) {
111+
SortedMultiset<BigInteger> factors = new SortedMultiset_BottomUp<>();
112+
for (int i=0; i<primes.size(); i++) {
113+
factors.add(primes.get(i), exponents.get(i));
114+
}
115+
return factors;
116+
}
117+
118+
public static void main(String[] argv) {
119+
ConfigUtil.initProject();
120+
runRobinsRHTest();
121+
}
122+
}

0 commit comments

Comments
 (0)