primecount

primecount is a command-line program and C/C++ library that counts the number of primes ≤ x (maximum 10³¹) using highly optimized implementations of the combinatorial prime counting algorithms.

primecount includes implementations of all important combinatorial prime counting algorithms known up to this date all of which have been parallelized using 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 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!

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.

cmake .
cmake --build . --parallel
sudo cmake --install .
sudo ldconfig

Detailed build instructions

Usage examples

# 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
      --double-check       Recompute pi(x) with alternative alpha tuning
                           factor(s) to verify the first result.
  -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 <X> <A>        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
10¹⁰	455,052,511	0.01s	0.00s	0.00s	0.00s	0.00s
10¹¹	4,118,054,813	0.01s	0.01s	0.01s	0.01s	0.00s
10¹²	37,607,912,018	0.01s	0.01s	0.01s	0.01s	0.01s
10¹³	346,065,536,839	0.03s	0.02s	0.01s	0.01s	0.01s
10¹⁴	3,204,941,750,802	0.10s	0.05s	0.03s	0.03s	0.02s
10¹⁵	29,844,570,422,669	0.46s	0.20s	0.10s	0.08s	0.05s
10¹⁶	279,238,341,033,925	3.01s	1.09s	0.40s	0.31s	0.15s
10¹⁷	2,623,557,157,654,233	24.01s	8.40s	1.75s	1.26s	0.48s
10¹⁸	24,739,954,287,740,860	203.37s	75.44s	8.04s	5.29s	1.77s
10¹⁹	234,057,667,276,344,607	NaN	NaN	NaN	24.41s	7.08s
10²⁰	2,220,819,602,560,918,840	NaN	NaN	NaN	113.75s	28.55s
10²¹	21,127,269,486,018,731,928	NaN	NaN	NaN	502.48s	116.47s
10²²	201,467,286,689,315,906,290	NaN	NaN	NaN	2,206.47s	477.90s

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 330 CPU core hours on the AMD EPYC Zen4 CPU!

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. Hard-Special-Leaves.pdf explains this algorithm in more detail. The novelties of primecount's easy special leaf implementation are described in Easy-Special-Leaves.pdf, and its partial sieve function implementation is described in Partial-Sieve-Function.pdf.

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[3]{x}\ \log^3{x})$ space.

C API

Include the <primecount.h> 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.

#include <primecount.h>
#include <stdio.h>

int main()
{
    int64_t pix = primecount_pi(1000);
    printf("primes <= 1000: %ld\n", pix);

    return 0;
}

C++ API

Include the <primecount.hpp> 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.

#include <primecount.hpp>
#include <iostream>

int main()
{
    int64_t pix = primecount::pi(1000);
    std::cout << "primes <= 1000: " << pix << std::endl;

    return 0;
}

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
Rust:	primecount-rs

Many thanks to the developers of these bindings!

Sponsors

Thanks to all current and past sponsors of primecount! 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.

Uh oh!

License

kimwalisch/primecount

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases 98

Sponsor this project

Uh oh!

Uh oh!

Contributors 5

Languages