Dana Jacobsen > Math-Prime-Util-0.25 > Math::Prime::Util::PP

Math-Prime-Util-0.25.tar.gz

Dependencies

Annotate this POD

Website

# CPAN RT

 Open 0
View/Report Bugs
Module Version: 0.24   Source   Latest Release: Math-Prime-Util-0.39

# NAME

Math::Prime::Util::PP - Pure Perl version of Math::Prime::Util

Version 0.14

# SYNOPSIS

The functionality is basically identical to Math::Prime::Util, as this module is just the Pure Perl implementation.

```  # Normally you would just import the functions you are using.
# Nothing is exported by default.
use Math::Prime::Util ':all';

# Get a big array reference of many primes
my \$aref = primes( 100_000_000 );

# All the primes between 5k and 10k inclusive
my \$aref = primes( 5_000, 10_000 );

# If you want them in an array instead
my @primes = @{primes( 500 )};

# is_prime returns 0 for composite, 2 for prime
say "\$n is prime"  if is_prime(\$n);

# is_prob_prime returns 0 for composite, 2 for prime, and 1 for maybe prime
say "\$n is ", qw(composite maybe_prime? prime)[is_prob_prime(\$n)];

# step to the next prime (returns 0 if the next one is more than ~0)
\$n = next_prime(\$n);

# step back (returns 0 if given input less than 2)
\$n = prev_prime(\$n);

# Return Pi(n) -- the number of primes E<lt>= n.
\$primepi = prime_count( 1_000_000 );
\$primepi = prime_count( 10**14, 10**14+1000 );  # also does ranges

# Quickly return an approximation to Pi(n)
my \$approx_number_of_primes = prime_count_approx( 10**17 );

# Lower and upper bounds.  lower <= Pi(n) <= upper for all n
die unless prime_count_lower(\$n) <= prime_count(\$n);
die unless prime_count_upper(\$n) >= prime_count(\$n);

# Return p_n, the nth prime
say "The ten thousandth prime is ", nth_prime(10_000);

# Return a quick approximation to the nth prime
say "The one trillionth prime is ~ ", nth_prime_approx(10**12);

# Lower and upper bounds.   lower <= nth_prime(n) <= upper for all n
die unless nth_prime_lower(\$n) <= nth_prime(\$n);
die unless nth_prime_upper(\$n) >= nth_prime(\$n);

# Get the prime factors of a number
@prime_factors = factor( \$n );

# Precalculate a sieve, possibly speeding up later work.
prime_precalc( 1_000_000_000 );

# Free any memory used by the module.
prime_memfree;

# Alternate way to free.  When this leaves scope, memory is freed.
my \$mf = Math::Prime::Util::MemFree->new;

# Random primes
my \$small_prime = random_prime(1000);      # random prime <= limit
my \$rand_prime = random_prime(100, 10000); # random prime within a range
my \$rand_prime = random_ndigit_prime(6);   # random 6-digit prime```

# DESCRIPTION

Pure Perl implementations of prime number utilities that are normally handled with XS or GMP. Having the Perl implementations (1) provides examples, (2) allows the functions to run even if XS isn't available, and (3) gives big number support if Math::Prime::Util::GMP isn't available. This is a subset of Math::Prime::Util's functionality.

All routines should work with native integers or multi-precision numbers. To enable big numbers, use bigint or bignum:

```    use bigint;
say prime_count_approx(1000000000000000000000000)'
# says 18435599767347543283712```

This is still experimental, and some functions will be very slow. The Math::Prime::Util::GMP module has much faster versions of many of these functions. Alternately, Math::Pari has a lot of these types of functions.

# FUNCTIONS

## is_prime

`  print "\$n is prime" if is_prime(\$n);`

Returns 2 if the number is prime, 0 if not. For numbers larger than `2^64` it will return 0 for composite and 1 for probably prime, using a strong BPSW test. Also note there are probabilistic prime testing functions available.

## primes

Returns all the primes between the lower and upper limits (inclusive), with a lower limit of `2` if none is given.

An array reference is returned (with large lists this is much faster and uses less memory than returning an array directly).

```  my \$aref1 = primes( 1_000_000 );
my \$aref2 = primes( 1_000_000_000_000, 1_000_000_001_000 );

my @primes = @{ primes( 500 ) };

print "\$_\n" for (@{primes( 20, 100 )});```

Sieving will be done if required. The algorithm used will depend on the range and whether a sieve result already exists. Possibilities include trial division (for ranges with only one expected prime), a Sieve of Eratosthenes using wheel factorization, or a segmented sieve.

## next_prime

`  \$n = next_prime(\$n);`

Returns the next prime greater than the input number. If the input is not a bigint, then 0 is returned if the next prime is larger than a native integer type (the last representable primes being `4,294,967,291` in 32-bit Perl and `18,446,744,073,709,551,557` in 64-bit).

## prev_prime

`  \$n = prev_prime(\$n);`

Returns the prime smaller than the input number. 0 is returned if the input is `2` or lower.

## prime_count

```  my \$primepi = prime_count( 1_000 );
my \$pirange = prime_count( 1_000, 10_000 );```

Returns the Prime Count function `Pi(n)`, also called `primepi` in some math packages. When given two arguments, it returns the inclusive count of primes between the ranges (e.g. `(13,17)` returns 2, `14,17` and `13,16` return 1, and `14,16` returns 0).

The Lehmer method is used for large values, which speeds up results greatly.

## nth_prime

`  say "The ten thousandth prime is ", nth_prime(10_000);`

Returns the prime that lies in index `n` in the array of prime numbers. Put another way, this returns the smallest `p` such that `Pi(p) >= n`.

The Lehmer prime count is used to speed up results for large inputs, but both methods take quite a bit of time and space. Think abut whether a bound or approximation would be acceptable instead.

## miller_rabin

```  my \$maybe_prime = is_strong_pseudoprime(\$n, 2);
my \$probably_prime = is_strong_pseudoprime(\$n, 2, 3, 5, 7, 11, 13, 17);```

Takes a positive number as input and one or more bases. The bases must be greater than 1. Returns 2 is `n` is definitely prime, 1 if `n` is probably prime, and 0 if `n` is definitely composite. Since this is just the Miller-Rabin test, a value of 2 is only returned for inputs of 2 and 3, which are shortcut. If 0 is returned, then the number really is a composite. If 1 is returned, there is a good chance the number is prime (depending on the input and the bases), but we cannot be sure.

This is usually used in combination with other tests to make either stronger tests (e.g. the strong BPSW test) or deterministic results for numbers less than some verified limit (such as the `is_prob_prime` function in this module).

## is_strong_lucas_pseudoprime

Takes a positive number as input, and returns 1 if the input is a strong Lucas pseudoprime using the Selfridge method of choosing D, P, and Q (some sources call this a strong Lucas-Selfridge pseudoprime). This is one half of the BPSW primality test (the Miller-Rabin strong pseudoprime test with base 2 being the other half).

## is_aks_prime

Takes a positive number as input, and returns 1 if the input can be proven prime using the AKS primality test. This code is included for completeness and as an example, but is impractically slow.

# UTILITY FUNCTIONS

## prime_precalc

`  prime_precalc( 1_000_000_000 );`

Let the module prepare for fast operation up to a specific number. It is not necessary to call this, but it gives you more control over when memory is allocated and gives faster results for multiple calls in some cases. In the current implementation this will calculate a sieve for all numbers up to the specified number.

## prime_memfree

`  prime_memfree;`

Frees any extra memory the module may have allocated. Like with `prime_precalc`, it is not necessary to call this, but if you're done making calls, or want things cleanup up, you can use this. The object method might be a better choice for complicated uses.

# FACTORING FUNCTIONS

## factor

```  my @factors = factor(3_369_738_766_071_892_021);
# returns (204518747,16476429743)```

Produces the prime factors of a positive number input, in numerical order. The special cases of `n = 0` and `n = 1` will return `n`, which guarantees multiplying the factors together will always result in the input value, though those are the only cases where the returned factors are not prime.

## trial_factor

`  my @factors = trial_factor(\$n);`

Produces the prime factors of a positive number input. The factors will be in numerical order. The special cases of `n = 0` and `n = 1` will return `n`, while with all other inputs the factors are guaranteed to be prime. For large inputs this will be very slow.

## fermat_factor

`  my @factors = fermat_factor(\$n);`

Currently unimplementated in Perl.

## holf_factor

`  my @factors = holf_factor(\$n);`

Produces factors, not necessarily prime, of the positive number input. An optional number of rounds can be given as a second parameter. It is possible the function will be unable to find a factor, in which case a single element, the input, is returned. This uses Hart's One Line Factorization with no premultiplier. It is an interesting alternative to Fermat's algorithm, and there are some inputs it can rapidly factor. In the long run it has the same advantages and disadvantages as Fermat's method.

## squfof_factor

`  my @factors = squfof_factor(\$n);`

Currently unimplementated in Perl.

## pminus1_factor

```  my @factors = prho_factor(\$n);

# Use a very small number of rounds
my @factors = prho_factor(\$n, 1000);```

Produces factors, not necessarily prime, of the positive number input. An optional number of rounds can be given as a second parameter. These attempt to find a single factor using one of the probabilistic algorigthms of Pollard Rho, Brent's modification of Pollard Rho, or Pollard's `p - 1`. These are more specialized algorithms usually used for pre-factoring very large inputs, or checking very large inputs for naive mistakes. If the input is prime or they run out of rounds, they will return the single input value. On some inputs they will take a very long time, while on others they succeed in a remarkably short time.

# MATHEMATICAL FUNCTIONS

## ExponentialIntegral

`  my \$Ei = ExponentialIntegral(\$x);`

Given a non-zero floating point input `x`, this returns the real-valued exponential integral of `x`, defined as the integral of `e^t/t dt` from `-infinity` to `x`.

If the bignum module has been loaded, all inputs will be treated as if they were Math::BigFloat objects.

We first check to see if the Math::MPFR module is installed. If so, then it is used, as it will return results much faster and can be more accurate. Accuracy when using MPFR will be 17 digits for non-BigInt/BigFloats, and for BigInt/BigFloat inputs will be equal to the `accuracy()` value of the input (or the default BigFloat accuracy, which is 40 by default).

MPFR is used for positive inputs only. If Math::MPFR is not installed or the input is negative, then other methods are used: continued fractions (`x < -1`), rational Chebyshev approximation (` -1 < x < 0`), a convergent series (small positive `x`), or an asymptotic divergent series (large positive `x`). Accuracy should be at least 14 digits.

## LogarithmicIntegral

`  my \$li = LogarithmicIntegral(\$x)`

Given a positive floating point input, returns the floating point logarithmic integral of `x`, defined as the integral of `dt/ln t` from `0` to `x`. If given a negative input, the function will croak. The function returns 0 at `x = 0`, and `-infinity` at `x = 1`.

This is often known as `li(x)`. A related function is the offset logarithmic integral, sometimes known as `Li(x)` which avoids the singularity at 1. It may be defined as `Li(x) = li(x) - li(2)`.

We first check to see if the Math::MPFR module is installed. If so, then it is used, as it will return results much faster and can be more accurate. Accuracy when using MPFR will be 17 digits for non-BigInt/BigFloats, and for BigInt/BigFloat inputs will be equal to the `accuracy()` value of the input (or the default BigFloat accuracy, which is 40 by default).

MPFR is used for inputs greater than 1 only. If Math::MPFR is not installed or the input is less than 1, results will be calculated as `Ei(ln x)`.

## RiemannZeta

`  my \$z = RiemannZeta(\$s);`

Given a floating point input `s` where `s >= 0.5`, returns the floating point value of ζ(s)-1, where ζ(s) is the Riemann zeta function. One is subtracted to ensure maximum precision for large values of `s`. The zeta function is the sum from k=1 to infinity of `1 / k^s`

If the bignum module has been loaded, all inputs will be treated as if they were Math::BigFloat objects.

We first check to see if the Math::MPFR module is installed. If so, then it is used, as it will return results much faster and can be more accurate. Accuracy when using MPFR will be 17 digits for non-BigInt/BigFloats, and for BigInt/BigFloat inputs will be equal to the `accuracy()` value of the input (or the default BigFloat accuracy, which is 40 by default).

If Math::MPFR is not installed, then results are calculated either from a table, rational Chebyshev approximation, or via a series.

## RiemannR

`  my \$r = RiemannR(\$x);`

Given a positive non-zero floating point input, returns the floating point value of Riemann's R function. Riemann's R function gives a very close approximation to the prime counting function.

If the bignum module has been loaded, all inputs will be treated as if they were Math::BigFloat objects.

We first check to see if the Math::MPFR module is installed. If so, then it is used, as it will return results much faster and can be more accurate. Accuracy when using MPFR will be 17 digits for non-BigInt/BigFloats, and for BigInt/BigFloat inputs will be equal to the `accuracy()` value of the input (or the default BigFloat accuracy, which is 40 by default).

# LIMITATIONS

The SQUFOF and Fermat factoring algorithms are not implemented yet.

Some of the prime methods use more memory than they should, as the segmented sieve is not properly used in `primes` and `prime_count`.

# PERFORMANCE

Performance compared to the XS/C code is quite poor for many operations. Some operations that are relatively close for small and medium-size values:

```  next_prime / prev_prime
is_prime / is_prob_prime
miller_rabin
ExponentialIntegral / LogarithmicIntegral / RiemannR
primearray```

Operations that are slower include:

```  primes
random_prime / random_ndigit_prime
factor / all_factors
nth_prime
primecount```

Performance improvement in this code is still possible. The prime sieve is over 2x faster than anything I was able to find online, but it is still has room for improvement.

Math::Prime::Util::GMP offers `C+XS+GMP` support for most of the important functions, and will be vastly faster for most operations. If you install that module, Math::Prime::Util will load it automatically, meaning you should not have to think about what code is actually being used (C, GMP, or Perl).

Memory use will generally be higher for the PP code, and in some cases much higher. Some of this may be addressed in a later release.

For small values (e.g. primes and prime counts under 10M) most of this will not matter.

Math::Prime::Util

Math::Prime::Util::GMP

# AUTHORS

Dana Jacobsen <dana@acm.org>