https://github.com/kimwalisch/primecount
🚀 Fast prime counting function library
https://github.com/kimwalisch/primecount
arm-sve avx512 math number-theory openmp prime-counting-function prime-numbers primecount primepi primes
Last synced: 5 months ago
JSON representation
🚀 Fast prime counting function library
- Host: GitHub
- URL: https://github.com/kimwalisch/primecount
- Owner: kimwalisch
- License: bsd-2-clause
- Created: 2013-06-09T21:03:30.000Z (over 12 years ago)
- Default Branch: master
- Last Pushed: 2025-05-14T17:41:54.000Z (5 months ago)
- Last Synced: 2025-05-14T18:49:22.582Z (5 months ago)
- Topics: arm-sve, avx512, math, number-theory, openmp, prime-counting-function, prime-numbers, primecount, primepi, primes
- Language: C++
- Homepage:
- Size: 8.76 MB
- Stars: 327
- Watchers: 23
- Forks: 41
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- Changelog: ChangeLog
- Funding: .github/FUNDING.yml
- License: COPYING
Awesome Lists containing this project
README
# primecount
[](https://github.com/kimwalisch/primecount/actions/workflows/ci.yml) [](https://github.com/kimwalisch/primecount/actions/workflows/benchmark.yml)
[](https://github.com/kimwalisch/primecount/releases)
[](doc/libprimecount.md)
[](doc/libprimecount.md)
primecount is a command-line program and C/C++ library that counts the number of
primes ≤ x (maximum 1031) using **highly optimized** implementations of the combinatorial
[prime counting algorithms](https://en.wikipedia.org/wiki/Prime-counting_function#Algorithms_for_evaluating_%CF%80(x)).
primecount includes implementations of all important combinatorial prime counting algorithms
known up to this date all of which have been parallelized using
[OpenMP](https://en.wikipedia.org/wiki/OpenMP). primecount contains the first ever open
source implementations of the Deleglise-Rivat algorithm and Xavier Gourdon's algorithm (that works).
primecount also features a [novel load balancer](https://github.com/kimwalisch/primecount/blob/master/src/LoadBalancerS2.cpp)
that is shared amongst all implementations and that scales up to hundreds of CPU cores. primecount
has already been used to compute several prime counting function [world records](doc/Records.md).
## Installation
The primecount command-line program is available in a few package managers.
For doing development with libprimecount you may need to install
```libprimecount-dev``` or ```libprimecount-devel```.
Windows:
winget install primecount
macOS:
brew install primecount
Arch Linux:
sudo pacman -S primecount
Debian/Ubuntu:
sudo apt install primecount
Fedora:
sudo dnf install primecount
FreeBSD:
pkg install primecount
openSUSE:
sudo zypper install primecount
## Build instructions
You need to have installed a C++ compiler and CMake. Ideally
primecount should be compiled using GCC or Clang as these compilers
support both OpenMP (multi-threading library) and 128-bit integers.
```sh
cmake .
cmake --build . --parallel
sudo cmake --install .
sudo ldconfig
```
* [Detailed build instructions](doc/BUILD.md)
## Usage examples
```sh
# Count the primes ≤ 10^14
primecount 1e14
# Print progress and status information during computation
primecount 1e20 --status
# Count primes using Meissel's algorithm
primecount 2**32 --meissel
# Find the 10^14th prime using 4 threads
primecount 1e14 --nth-prime --threads=4 --time
```
## Command-line options
```
Usage: primecount x [options]
Count the number of primes less than or equal to x (<= 10^31).
Options:
-d, --deleglise-rivat Count primes using the Deleglise-Rivat algorithm
-g, --gourdon Count primes using Xavier Gourdon's algorithm.
This is the default algorithm.
-l, --legendre Count primes using Legendre's formula
--lehmer Count primes using Lehmer's formula
--lmo Count primes using Lagarias-Miller-Odlyzko
-m, --meissel Count primes using Meissel's formula
--Li Eulerian logarithmic integral function
--Li-inverse Approximate the nth prime using Li^-1(x)
-n, --nth-prime Calculate the nth prime
-p, --primesieve Count primes using the sieve of Eratosthenes
--phi phi(x, a) counts the numbers <= x that are not
divisible by any of the first a primes
-R, --RiemannR Approximate pi(x) using the Riemann R function
--RiemannR-inverse Approximate the nth prime using R^-1(x)
-s, --status[=NUM] Show computation progress 1%, 2%, 3%, ...
Set digits after decimal point: -s1 prints 99.9%
--test Run various correctness tests and exit
--time Print the time elapsed in seconds
-t, --threads=NUM Set the number of threads, 1 <= NUM <= CPU cores.
By default primecount uses all available CPU cores.
-v, --version Print version and license information
-h, --help Print this help menu
```
Advanced options
```
Advanced options for the Deleglise-Rivat algorithm:
-a, --alpha=NUM Set tuning factor: y = x^(1/3) * alpha
--P2 Compute the 2nd partial sieve function
--S1 Compute the ordinary leaves
--S2-trivial Compute the trivial special leaves
--S2-easy Compute the easy special leaves
--S2-hard Compute the hard special leaves
Advanced options for Xavier Gourdon's algorithm:
--alpha-y=NUM Set tuning factor: y = x^(1/3) * alpha_y
--alpha-z=NUM Set tuning factor: z = y * alpha_z
--AC Compute the A + C formulas
--B Compute the B formula
--D Compute the D formula
--Phi0 Compute the Phi0 formula
--Sigma Compute the 7 Sigma formulas
```
## Benchmarks
x
Prime Count
Legendre
Meissel
Lagarias
Miller
Odlyzko
Deleglise
Rivat
Gourdon
1010
455,052,511
0.01s
0.00s
0.00s
0.00s
0.00s
1011
4,118,054,813
0.01s
0.01s
0.01s
0.01s
0.00s
1012
37,607,912,018
0.02s
0.01s
0.01s
0.01s
0.01s
1013
346,065,536,839
0.03s
0.02s
0.02s
0.02s
0.01s
1014
3,204,941,750,802
0.11s
0.05s
0.03s
0.03s
0.02s
1015
29,844,570,422,669
0.45s
0.21s
0.14s
0.13s
0.06s
1016
279,238,341,033,925
3.09s
1.12s
0.41s
0.31s
0.20s
1017
2,623,557,157,654,233
25.28s
8.84s
1.81s
1.27s
0.51s
1018
24,739,954,287,740,860
214.63s
78.00s
8.18s
5.33s
2.00s
1019
234,057,667,276,344,607
NaN
NaN
NaN
24.40s
8.12s
1020
2,220,819,602,560,918,840
NaN
NaN
NaN
113.60s
32.87s
1021
21,127,269,486,018,731,928
NaN
NaN
NaN
500.51s
134.21s
1022
201,467,286,689,315,906,290
NaN
NaN
NaN
2,198.92s
552.17s
The benchmarks above were run on an AMD EPYC Zen4 CPU from 2023 with 32 CPU cores (no Hyper-Threading)
clocked at 3.7 GHz. Note that Jan Büthe mentions in [11]
that he computed $\pi(10^{25})$ in 40,000 CPU core hours using the analytic prime
counting function algorithm. Büthe also mentions that by using additional zeros of the
zeta function the runtime could have potentially been reduced to 4,000 CPU core hours.
However using primecount and Xavier Gourdon's algorithm $\pi(10^{25})$ can be computed
in only 380 CPU core hours on the AMD EPYC Zen4 CPU (from 2023)!
## Algorithms
Legendre's Formula
$\pi(x)=\pi(\sqrt{x})+\phi(x,\pi(\sqrt{x}))-1$
Meissel's Formula
$\pi(x)=\pi(\sqrt[3]{x})+\phi(x,\pi(\sqrt[3]{x}))-\mathrm{P_2}(x,\pi(\sqrt[3]{x}))-1$
Lehmer's Formula
$\pi(x)=\pi(\sqrt[4]{x})+\phi(x,\pi(\sqrt[4]{x}))-\mathrm{P_2}(x,\pi(\sqrt[4]{x}))-\mathrm{P_3}(x,\pi(\sqrt[4]{x}))-1$
LMO Formula
$\pi(x)=\pi(\sqrt[3]{x})+\mathrm{S_1}(x,\pi(\sqrt[3]{x}))+\mathrm{S_2}(x,\pi(\sqrt[3]{x}))-\mathrm{P_2}(x,\pi(\sqrt[3]{x}))-1$
Up until the early 19th century the most efficient known method for counting primes was the
sieve of Eratosthenes which has a running time of $O(x\ \log\ \log\ x)$ operations. The first
improvement to this bound was Legendre's formula (1830) which uses the inclusion-exclusion
principle to calculate the number of primes below x without enumerating the individual
primes. Legendre's formula has a running time of $O(x)$ operations and uses $O(\sqrt{x}/\log{x})$
space. In 1870 E. D. F. Meissel improved Legendre's formula by setting $a=\pi(\sqrt[3]{x})$
and by adding the correction term $\mathrm{P_2}(x,a)$, Meissel's formula has a running time
of $O(x/\log^3{x})$ operations and uses $O(\sqrt[3]{x})$ space. In 1959 D. H. Lehmer
extended Meissel's formula and slightly improved the running time to $O(x/\log^4{x})$
operations and $O(x^{\frac{3}{8}})$ space. In 1985 J. C. Lagarias, V. S. Miller and A. M.
Odlyzko published a new algorithm based on Meissel's formula which has a lower runtime
complexity of $O(x^{\frac{2}{3}}/\log{x})$ operations and which uses only
$O(\sqrt[3]{x}\ \log^2{x})$ space.
primecount's Legendre, Meissel and Lehmer implementations are based
on Hans Riesel's book [5],
its Lagarias-Miller-Odlyzko and Deleglise-Rivat implementations are
based on Tomás Oliveira's paper [9]
and the implementation of Xavier Gourdon's algorithm is based
on Xavier Gourdon's paper [7].
primecount's implementation of the so-called hard special leaves is different
from the algorithms that have been described in any of the combinatorial
prime counting papers so far. Instead of using a binary indexed tree
for counting which is very cache inefficient primecount uses a linear
counter array in combination with the POPCNT instruction which is more
cache efficient and much faster. The
[Hard-Special-Leaves.md](doc/Hard-Special-Leaves.md) document contains more
information. primecount's [easy special leaf implementation](doc/Easy-Special-Leaves.md)
and its [partial sieve function implementation](doc/Partial-Sieve-Function.md)
also contain significant improvements.
## Fast nth prime calculation
The most efficient known method for calculating the nth prime is a combination
of the prime counting function and a prime sieve. The idea is to closely
approximate the nth prime e.g. using the inverse logarithmic integral
$\mathrm{Li}^{-1}(n)$ or the inverse Riemann R function $\mathrm{R}^{-1}(n)$
and then count the primes up to this guess using the prime counting function.
Once this is done one starts sieving (e.g. using the segmented sieve of
Eratosthenes) from there on until one finds the actual nth prime. The author
has implemented ```primecount::nth_prime(n)``` this way
(option: ```--nth-prime```), it finds the nth prime in $O(x^{\frac{2}{3}}/\log^2{x})$
operations using $O(\sqrt{x})$ space.
## C API
Include the `````` header to use primecount's C API.
All functions that are part of primecount's C API return ```-1``` in case an
error occurs and print the corresponding error message to the standard error
stream.
```C
#include
#include
int main()
{
int64_t pix = primecount_pi(1000);
printf("primes <= 1000: %ld\n", pix);
return 0;
}
```
* [C API documentation](doc/libprimecount.md#libprimecount)
* [libprimecount build instructions](doc/libprimecount.md#build-instructions)
## C++ API
Include the `````` header to use primecount's C++ API.
All functions that are part of primecount's C++ API throw a
```primecount_error``` exception (which is derived from
```std::exception```) in case an error occurs.
```C++
#include
#include
int main()
{
int64_t pix = primecount::pi(1000);
std::cout << "primes <= 1000: " << pix << std::endl;
return 0;
}
```
* [C++ API documentation](doc/libprimecount.md#libprimecount)
* [libprimecount build instructions](doc/libprimecount.md#build-instructions)
## Bindings for other languages
primesieve natively supports C and C++ and has bindings available for:
Common Lisp:
cl-primecount
Julia:
primecount_jll.jl
Lua:
lua-primecount
Haskell:
primecount-haskell
Python:
primecountpy
Python:
primecount-python
Rust:
primecount-rs
Many thanks to the developers of these bindings!
## Sponsors
Thanks to all current and past [sponsors of primecount](https://github.com/sponsors/kimwalisch)! Your donations help me purchase (or rent) the latest CPUs and ensure primecount runs at maximum performance on them. Your donations also motivate me to continue maintaining primecount.
