Revision history for Perl module Math::Prime::Util::GMP

0.34 2015-10-14


    - sieve_prime_cluster(low,high,...)   sieve clusters/constellations


    - Speedup partial sieve with large range.


    - Remove _GMP_trial_primes(), which was never exported.
    - Internal restructuring of sieve_primes and sieve_twin_primes.
    - is_frobenius_pseudoprime with arguments doesn't check for perfect
      square, and works for small primes plus large params.

0.33 2015-09-04


    - sieve_twin_primes(low,high)         sieve for twin primes
    - is_miller_prime(n[,assumeGRH])      deterministic Miller test


    - New results from Sorenson and Webster let us give faster deterministic
      results for 65-82 bits.  is_prime always returns {0,2} for this range.

0.32 2015-08-16


    - chinese                   chinese remainder theorem
    - sigma                     divisor sums
    - ramanujan_tau             Ramanujan's Tau function

0.31 2015-06-21


    - Minor speedup to partial sieve.


    - Allow working on old GMP versions.

0.30 2015-06-15


    - harmfrac                           returns (num,den) of Harmonic number
    - harmreal                           returns float value of Harmonic number
    - is_proth_prime(p)                  For k*2^n+1, returns -1, 0, or 2
    - is_frobenius_khashin_pseudoprime   returns 1 if Frob-Khashin prob prime


    - lucas sequence with even n fixed.


    - A Proth test was added to quickly prove numbers of the form k*2^n+1.

    - LLR testing was improved using a method by Rödseth.  This allows proofs
      of k*2^n-1.  The old method is still used, but was unable to quickly
      test cases where k was divisible by 3.  The new method handles these.

    - BLS75-5 proof: use an expanding stack, allowing it to work on inputs
      like:  'k * n# + 1'.

    - BLS75-5 proof: remove some redundant computations.

0.29 2014-11-26


    - is_llr_prime(p)           For k*2^n-1, returns -1, 0, or 2
    - lucasu(P, Q, k)           U_k for Lucas(P,Q)
    - lucasv(P, Q, k)           V_k for Lucas(P,Q)


    - is_prime will prove many Proth-form (h*2^n+1) numbers.

    - is_provable_prime tries less hard to make a BLS75-T5 proof.  Certs may
      be longer, but performance is better.

    - is_power is more efficient (recursion removed, only prime powers checked).

0.28 2014-11-17


    - is_mersenne_prime(p)      returns 1 iff 2^p-1 is prime


    - is_prime will do a LLR test, as will is_provable_prime if not returning
      a certificate.  This means many primes of the form k*2^n-1 will run
      faster and return 2 rather than 1.

    - Update UV SQUFOF factoring code, faster factoring once reduced in size.

    - Slightly better P-1 stage 2 performance.

    - Slightly deeper trial division in general factoring.

    - Big reduction in average depth of unfactored stack.  We work on smaller
      composite factors first, and add repeated factors all at once.  This
      fixes some pathological inputs such as:
          vecprod( map { $_*($_+2)**17 } @{twin_primes(100000,115000)} )
      which has 2574 factors and would overflow the 256-element stack.  With
      the new code it has a maximum stack depth of 3.


    - is_power works with negative powers, although doesn't return root.

0.27 2014-10-07


    - Minor changes to factor recipe, should give a little speedup.

    - Cache ~32k worth of small primes to give a little speedup in many places.

    - Switch to my original AGM code, slightly faster for large values.

    - Add Goetgheluck binomial code, and switch to mpz_bin_uiui for builtin.
      For large inputs this can be thousands of times faster than mpz_bin_ui.


    - Don't use mp_bitcnt_t -- old GMPs don't have this type.

0.26 2014-09-26


    - stirling(n,m,[type])      Stirling numbers of first,second,third kind
    - vecprod(list)             product of a list of integers


    - Cleanup invmod, etc. XS parser.  Smaller code.

    - Fixed some leaked mpz_t / mpz_f objects.

0.25 2014-09-23

    - Fixed compiler warning (error for some compilers).

    - prev_prime uses a sieve for 200+ bits.  20% speedup for large inputs.

0.24 2014-09-22


    - sieve_primes(low,high[,k])          sieve for primes, partial or BPSW
    - is_frobenius_pseudoprime(n,[a,b])   Frobenius quadratic primality test
    - is_perrin_pseudoprime(n)            Perrin primality test
    - factorial(n)                        n!
    - bernfrac                            returns (num,den) of Bernoulli number
    - Pi([digits])                        Pi with requested number of digits


    - next_prime will use a partial sieve for 120+ bit inputs.  For large
      inputs this is a 15-30% speedup.  For 2469*2617#/93030-12182 I get:

         = 392.2s  OpenPFGW 3.7.7
         = 220.6s  Pari/GP 2.6.2
         = 128.4s  GMP 5.0.2 mpz_nextprime
         =  57.6s  old MPU
         =  45.5s  new MPU

    - New version of Frobenius-Underwood test to match the 2014 draft paper.
      This is just a code refresh and has no other effect.

    - BLS75 with effort 1 toned down.  This makes is_prime with 65- to 200-bit
      inputs faster, though a bit less likely to return with the value 2
      rather than 1.  It's a couple percent fewer, but 10-60% faster.

0.23 2014-08-16

    - Fat comma isn't fat for numbers, garbled test hashes on 32-bit.

0.22 2014-08-16


    - moebius(n[,nhi])                    Moebius function (single or ranged)
    - liouville(n)                        Liouville function
    - totient(n)                          Euler's Totient function (single)
    - jordan_totient(k, n)                Jordan totient
    - carmichael_lambda(n)                Carmichael Lambda (reduced totient)
    - znorder(a, n)                       multiplicative order of a mod n
    - znprimroot(n)                       least primitive root of n


    - Moved factoring loop out of XS file.

    - factor does much better power splitting, similar to MPU 0.38's code:
      time mpu 'use bigint; my $n = next_prime(10**20)**200; say join(" ", map {"[@$_]"} factor_exp($n));'
      time mpu 'use bigint; my $n = next_prime(10**21)**200 * next_prime(10**20)**200; say join(" ", map {"[@$_]"} factor_exp($n));'

    - Fix spelling of Paul Zimmermann's name (thanks to Mathew @ mersenneforum)

    - Standalone ECPP now does expression parsing using the GMP 6.0.0a demo
      code.  Version bumped to 1.04.

0.21 2014-06-19

    - Used a bare 64-bit in a test.  Wrap in quotes.

0.20 2014-06-18


    - valuation(a,b)                      how many times does b divide a?
    - invmod(a,n)                         inverse of a modulo n
    - is_pseudoprime(n,base)              Simple Fermat test
    - binomial(n,k)                       binomial coefficient
    - gcdext(a,b)                         extended Euclidian algorithm
    - vecsum(...)                         sum list of integers


    - 10%-ish speedup for next/prev prime with 38-950 digit inputs.

0.19 2014-04-21


    - is_power
    - exp_mangoldt


    - Fixed string shortcut for simple divisibility.  is_prime and related
      functions are a bit faster when given inputs divisible by 2 or 5.


    - Add improved AKS parameter selection.  About 200x faster, though still
      thousands of times slower than APR-CL or ECPP.  Updated times for the
      example in the v0.10 entry: Timing for 10**100+267:
          AKS:         ~5 days.
          BLS75 n-1:   ~3 minutes.
          APR-CL:      0.09 seconds
          ECPP:        0.05 seconds.

    - ECPP performance adjustments, version 1.03 of standalone ECPP.

    - Updated ECPP class polynomial data.  Default "tiny" table had very minor
      changes.  The "big" table (in the github xt/ directory, default for
      standalone ECPP) removed some large coefficient 17-24 degree polys to
      make room for many more higher-degree polys.  For some ranges this may
      mean more backtracking, but should expand the input size that is able to
      find good discriminants without high factoring effort.  "prob" below is
      summing the estimate 1/2H:   9x more polys and 66x larger size gives on
      average about 3x more candidates.

      Default "tiny" table:
        OLD:    30373 bytes   604 polys    24 maxdeg   42.0 prob   1450 prob/MB
        NEW:    30422 bytes   611 polys    25 maxdeg   42.8 prob   1475 prob/MB

      "big"  table at
        OLD:  2032376 bytes  3197 polys   117 maxdeg  104.5 prob     54 prob/MB
        NEW:  2005072 bytes  5271 polys    85 maxdeg  125.2 prob     65 prob/MB

      "huge" table at
             15724395 bytes 14571 polys   128 maxdeg  207.9 prob     14 prob/MB

0.18 2014-01-27


    - Fix for 5.6.2 (undefined symbol).

    - Fix for unsigned long != UV, reported by CHORNY.

0.17 2014-01-24


    - is_bpsw_prime     specific BPSW-only test
    - gcd               20-50x faster than Math::BigInt
    - lcm               3-800x faster than Math::BigInt
    - kronecker


    - Factoring with a number or intermediate near the word boundary would
      hang or run very slow.  Thanks to Hugo van der Sanden for the report.

    - Next version of vcert.c, which handles some new Primo changes.

0.16 2013-10-28


    - partitions    partition function p(n), OEIS A000041


    - Fixed memory leak in Lucas sequence (is_prime, next_prime, etc.).

    - is_aks_prime wasn't properly checking divisibility for composites.

    [Scripts and Programs Added]

    -    parallel prime gap verification

0.15 2013-09-30

    [Functions Added]
      - miller_rabin_random

    - A tree sieve is done in trial factor for large (900+ digits) inputs.
      This improves performance greatly for very large inputs.

    - is_prob_prime uses more trial division for large inputs.  For very
      large inputs (e.g. 50,000+ digits) this can greatly speed up probable
      prime testing, for instance in next_prime or similar sieving.
      Time for next_prime(99992 * 10**10101 - 100):
         1m  4s  MPUGMP 0.15
         3m 34s  Pari/GP (needs 450MB of stack!)
         4m  1s  mpz_nextprime
         9m 33s  Math::Primality

    - Use shallow product tree for primorials.  Large primorials are 2 to 12
      times faster.  Break consecutive_integer_lcm into four sub-products so
      it runs 2-4x faster for large inputs.

    - Trim ECPP and adjust its heuristics.

    - Standalone ECPP now has consistent return codes, making it easier to
      use in applications without having to parse return text.  The return
      codes are consistent with the certificate verifier.

    - factor() in scalar context is now consistent.

0.14 2013-08-07

    - Fix small certificates leaving out the "N " for small numbers.

0.13 2013-08-06

    [API Changes]
      - Primality proofs now use a text certificate.  This is nicer for
        external interaction, but is a change from previous behavior.  You
        will need to use Math::Prime::Util 0.30 or newer.

    [Functions Added]
      - lucas_sequence
      - is_almost_extra_strong_lucas_pseudoprime
      - is_frobenius_underwood_pseudoprime
      - pplus1_factor

    - is_prob_prime now uses the extra-strong Lucas test instead of the
      strong Lucas test.  This gives better performance.  is_prime and
      is_provable_prime also incorporate the change.

    - Added more trial division to is_prob_prime for big (100+ digit)
      numbers.  This is a significant speedup for next_prime in many cases.
      Pari/gp 2.6.0  nextprime(10^4000)    19 minutes
      MPU:GMP 0.12   next_prime(10**4000)  15 minutes
      MPU:GMP 0.13   next_prime(10**4000)   8 minutes

    - ECPP now tries partial n-1 and n+1 proofs (BLS theorem 3 / 15) at each
      step, and adds a couple additional quick factoring tests.  This mainly
      helps lower the time variability with large inputs.

    - Updated ECPP polynomials.  Should give better performance with larger

    [Scripts and Programs Added]
      -    convert a Primo certificate to MPU format.
      -           Verify a Primo or MPU certificate.
      - vcert.c                  Verify a Primo or MPU certificate.

0.12 2013-06-12

    - add standard and extra strong Lucas probable prime tests.

    - Rearrange C code to allow standalone build of ECPP.

    - Speedups for ECPP.

0.11 2013-05-20

    - is_prob_prime is faster at finding composites.

    - rewrote Lucas inner loop for ~20% speedup.

    - The previous two changes make is_prob_prime a bit faster, which means
      a small speedup to almost all functions.

    - Lower is_prime proving effort.  Proves ~30% of 128-bit primes instead
      of 50%, but runs about 4x faster.

    - Change ECPP to factor all strategy with backtracking.  Not much
      difference below 200 digits, but a big help after that.  Certificates
      are identical.

0.10 2013-05-07

    - ECPP -- a much faster primality prover.  BLS75 n-1 works well to about
      40 digits, then slows down rapidly.  This ECPP implementation is good
      to 300-500 digits.  Timing for 10**100+267:
          AKS: ~1 year.    BLS75 n-1: 1.5-5 minutes.    ECPP: 0.1 seconds.

    - is_prime does an additional 4 random-base M-R tests.

    - is_provable_prime will try a quick n-1 then do ECPP.

    - is_nminus1_prime added to give access to that specific method, in
      case someone has reason to insist on that proof type.

    - Change polynomial multiplication to use binary segmentation.  Huge
      speed improvement for AKS primality proving (20-100x faster).  AKS
      is now faster in GMP than MPU's C code.  It's still not nearly as fast
      as other methods: proving 100000000003 takes 65 seconds, while this
      would take a couple milliseconds at most for an n-1 proof.  The one year
      estimate in the first paragraph is with the _new_ code.

    - Compile-time support to BLS75 theorem 7, which reduces the amount of
      n-1 we need to factor.  Not enabling because it just doesn't help
      enough, and ECPP is a better place to spend development effort.

    - Lots of new internal functions to support ECPP, which could be used
      for future projects.

0.09 2013-04-21

    - Add primality certificate generation.

0.08 2013-04-05

    - Switch to a projective ECM with a stage 2.  Much better results, but
      note that it doesn't build up to B1 like the old version.  This has
      a big impact on factoring and primality proving.

    - Add a QS based on William Hart's SIMPQS (a simple QS that is a
      predecessor to what went into FLINT).  Not the fastest by a long shot
      (yafu and msieve take that prize), but it's quite small and works pretty
      well.  Eventually this will get replaced with a home-built QS.  Meanwhile
      some improvements from version 2.0 that remain are (1) no partial
      relations, (2) uses too much memory, and (3) uses GE instead of
      jasonp's block Lanczos.

    - The new ECM and QS make factoring much faster, especially for 30+
      digit inputs.  Factoring should give reasonable times out to 70+
      digits now.  Time is competitive with Math::Pari now, and often faster
      (noting that Math::Pari uses a fairly old version of Pari).

    - Factoring mix redone given the big changes in ECM and QS.

    - Primality proofs adjusted to better use p-1 and ECM.  The quick proof
      in is_prime has a higher success rate for all input sizes and is a
      little faster for small numbers.  is_provable_prime is 10-50x faster.

0.07 2013-03-19

    - Tiny speedup when passing in bigints.

    - Some speedups in pbrent, pbrent usage, and small prime iterator.
      Factoring small (< ~30 digit) numbers is faster.

    - Handle large and small M-R bases just like MPU does -- mod with n,
      then return 1 if base <= 1 or base >= n-1.

0.06 2012-12-17

    - Fix 1-byte memory overrun (thanks to CPAN Testers, Solaris, Valgrind).

    - Add factoring of small numbers.  Helps a little when the input gets
      reduced enough to fit into a UV.

0.05 2012-12-15

    - Add AKS primality test.  Super slow, but nice to have around.

    - ECM is faster.

    - Add a small prime iterator, which means _much_ less memory and faster
      operation for big smoothness factors in pminus1 and ecm factoring.

0.04 2012-11-11

    - Add simple prime_count function.  It uses next_prime so is terribly slow
      for big ranges.  However it's a lot faster than the PP code when given
      a large base and small range e.g. (10**96, 10**96 + 2**18).

    - Add primorial, pn_primorial, and consecutive_integer_lcm functions.

    - Factoring:
         Add a perfect power test.
         Add a simple ECM factoring method.
         Speed up SQUFOF a bit.
         Complete p-1 rewrite.  Much faster and finds more factors.
         Adjust general factor() mix.

    - Add Pocklington-Lehmer and BLS primality tests.  is_prime() uses the
      BLS test with a quick factoring attempt for numbers less than 2^200,
      though the chances of success drop off as the size increases.
      The point is not to cull mismarked probable primes (we use BPSW so this
      is highly unlikely for these small sizes), but to quickly mark more
      numbers as definitely prime.  Remember to use is_prob_prime if you do
      not care about this distinction and want the result slightly faster.

    - add is_provable_prime function that calls BLS with much more aggressive

0.03 2012-07-16
    - XS callable: _lcm_of_consecutive_integers(B)
      which is a better alternative for B! for many factoring algorithms.
    - Fix some minor compile issues.

0.02 2012-07-15
    - Factoring tests assumed 64-bit.  Rewrite.

0.01 2012-07-15
    - Initial release