Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
PRIMECOUNT(1)							   PRIMECOUNT(1)

NAME
     primecount - count prime numbers

SYNOPSIS
     primecount x [options]

DESCRIPTION
     Count  the  number  of primes less than or equal to x (<= 10^31) using fast
     implementations of the combinatorial prime counting function algorithms. By
     default primecount counts primes using Xavier Gourdon's algorithm which has
     a runtime complexity of O(x^(2/3) / log^2 x) operations and uses  O(x^(2/3)
     *	log^3 x) memory. primecount is multi-threaded, it uses all available CPU
     cores by default.

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.  This  redundancy  helps guard against potential bugs in
	 primecount: if an error exists, it is highly unlikely that  both  pi(x)
	 computations would produce the same (incorrect) result.

     -g, --gourdon
	 Count primes using Xavier Gourdon's algorithm (default algorithm).

     -l, --legendre
	 Count primes using Legendre's formula.

     --lehmer
	 Count primes using Lehmer's formula.

     --lmo
	 Count primes using the Lagarias-Miller-Odlyzko algorithm.

     -m, --meissel
	 Count primes using Meissel's formula.

     --Li
	 Approximate  pi(x) using the Eulerian logarithmic integral: Li(x), with
	 Li(x) = li(x) - li(2).

     --Li-inverse
	 Approximate the nth prime using the inverse Eulerian logarithmic  inte-
	 gral: 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: R(x).

     --RiemannR-inverse
	 Approximate the  nth  prime  using  the  inverse  Riemann  R  function:
	 R^-1(x).

     --RiemannR-psi
	 Approximate  pi(x)  using  a  refined	Riemann R approximation based on
	 R(psi(x)). Compared  to  --RiemannR,  this  option  first  approximates
	 Chebyshev's  psi(x) using Riemann's explicit formula with the first 512
	 zeta zero gammas and then evaluates R(psi(x)). In practice this usually
	 estimates pi(x) more accurately than plain R(x).

     --RiemannR-psi-inverse
	 Approximate the nth prime using the inverse of  the  refined  R(psi(x))
	 approximation.  Compared to --RiemannR-inverse, this option inverts the
	 psi-corrected approximation instead of plain  R(x).  In  practice  this
	 usually estimates the nth prime more accurately than R^-1(x).

     -s, --status[=NUM]
	 Show  the computation progress e.g. 1%, 2%, 3%, ... Show NUM digits af-
	 ter the decimal point: --status=1 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 FOR THE DELEGLISE-RIVAT ALGORITHM
     --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.

   Tuning factor
     The alpha tuning factor mainly balances the computation of the S2_easy  and
     S2_hard  formulas.  By increasing alpha, the runtime of the S2_hard formula
     usually decreases, while the runtime of the S2_easy formula  increases.  By
     default,  primecount  automatically  selects an alpha tuning factor that is
     likely to provide the best performance for the user's input.

     The alpha tuning factor is also very useful for double checking pi(x)  com-
     putations. You compute pi(x) twice but for the second computation you use a
     slightly  different alpha factor. If the results of both pi(x) computations
     match then pi(x) has been verified successfully.

     -a, --alpha=NUM
	 Set the alpha tuning factor: y  =  x^(1/3)  *	alpha,	1  <=  alpha  <=
	 x^(1/6).

ADVANCED OPTIONS FOR XAVIER GOURDON'S ALGORITHM
     --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.

   Tuning factors
     The  alpha_y  and	alpha_z tuning factors mainly balance the computation of
     the A, B, C and D formulas. When alpha_y is decreased and	alpha_z  is  in-
     creased,  the  runtime of the B formula increases, while the runtime of the
     A, C and D formulas decrease. By default, primecount automatically  selects
     alpha_y and alpha_z tuning factors that are likely to provide the best per-
     formance for the user's input.

     Both the alpha_y and alpha_z tuning factors are also very useful for double
     checking  pi(x)  computations.  You  compute pi(x) twice but for the second
     computation you use slightly different alpha_y and/or alpha_z  tuning  fac-
     tors.  If	the results of both pi(x) computations match then pi(x) has been
     verified successfully.

     --alpha-y=NUM
	 Set the alpha_y tuning factor: y = x^(1/3) * alpha_y, 1 <=  alpha_y  <=
	 x^(1/6).

     --alpha-z=NUM
	 Set  the  alpha_z  tuning  factor:  z	=  y  * alpha_z, 1 <= alpha_z <=
	 x^(1/6).

DOUBLE CHECKING PI(X) COMPUTATIONS
     For large pi(x) computations that run over several weeks or months,  it  is
     important	to  verify  such computations to protect against miscalculations
     due to hardware errors and/or bugs in primecount.

     To verify a pi(x) computation, you compute pi(x) twice. But for the  second
     run  you  use  the --double-check option. The --double-check option enables
     the use of alternative alpha tuning factor(s), ensuring that  all	internal
     bounds  in  the second computation differ slightly from the first run. This
     redundancy helps guard against potential bugs in primecount:  if  an  error
     exists,  it  is  highly unlikely that both pi(x) computations would produce
     the same (incorrect) result.

     primecount 1e20 --status
	 First pi(x) computation using default alpha tuning factor(s).

     primecount 1e20 --status --double-check
	 Second pi(x) computation using alternative alpha tuning factor(s).

EXAMPLES
     primecount 1000
	 Count the primes <= 1000.

     primecount 1e17 --status
	 Count the primes <= 10^17 and print status information.

     primecount 1e15 --threads 1 --time
	 Count the primes <= 10^15 using a single  thread  and	print  the  time
	 elapsed.

HOMEPAGE
     https://github.com/kimwalisch/primecount

AUTHOR
     Kim Walisch <kim.walisch@gmail.com>

				   04/16/2026			   PRIMECOUNT(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=primecount&sektion=1&manpath=FreeBSD+Ports+15.1.quarterly>

home | help