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
	   integral: 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).

       -s, --status[=NUM]
	   Show	the computation	progress e.g. 1%, 2%, 3%, ... Show NUM digits
	   after 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)
       computations. 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
       increased, 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	performance 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 factors. 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>

				  11/03/2025			 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.0.quarterly>

home | help