This is an automated email from the git hooks/post-receive script.

gregoa pushed a change to annotated tag upstream/0.51
in repository libmath-prime-util-perl.

        at  a7bde13   (tag)
   tagging  73e672a0e91e7ccfaf56a12420a1a33664c58e35 (commit)
  replaces  upstream/0.50
 tagged by  gregor herrmann
        on  Sat Jun 27 19:16:46 2015 +0200

- Log -----------------------------------------------------------------
Upstream version 0.51

Dana Jacobsen (1291):
      Initial commit
      Add MemFree object for better memory control
      Add factoring
      text cleanup
      Add some items to do
      Updates for 32-bit behavior
      prime_count uses segmented sieve
      Updates for next release
      Speed up factoring a smidgeon, prep for 0.03
      Make squfof recurse, and fix some issues with it
      Miller-Rabin and prob_prime
      New tests and benchmarks
      factoring benchmarks
      Split out bitarray and type header files
      Redo factor loop
      Factoring is isprime updates
      More factoring changes
      pedantic cleanup
      Next prime overflow, HOLF factoring, compare with Pari
      Fix next_prime
      Factoring updates
      random primes, and no asserts
      Try another 64-bit detection method
      Rename some test files
      Changes for v0.04
      Tweak to mulmod use
      Add pseudoprime test for MR
      Note need for more pseudoprime testing
      Make asm x64 only
      More pseudoprime testing
      Add perfect square discriminator
      Overflow for nth_prime, segment prime_count
      Add math functions
      Rewrite prime_count for segments
      Updates from testing, make nth_prime_approx more accurate for large values
      Allow random_prime to use overridden rand
      Fix issue with sqrt rounding
      Small fixes
      Many more tests
      Move from mallloc/free to New/Safefree
      Update for 0.06
      Move Test::More to build vs. prereq; comment changes
      Update for 0.07
      Initial scaffolding for threads
      Accuracy for math functions
      Remove simple sieve
      7/11/13 presieve added
      7/11/13 presieve added
      Add add_factors
      Add rational Chebyshev approx for Ei
      Thread safety
      improve threading
      Improve threading
      Add tests for all_factors
      Segments were in MB instead of KB.  Waaaaay too much memory
      Add PrimeArray tied array
      Fiddle with Makefile.PL
      Add tests for primearray, move MemFree, prepare for 0.08 release
      Get ready for 0.08 release
      Start work on PP code
      Pure Perl working on all tests
      Big speedups for pure perl code, though still too slow
      threading and PP changes
      Wasn't correctly selecting win32
      Add documentation
      PP sieve benchmark, update tests, MR always returns 0 for even input
      Update timings, fix test plan
      Add some more implementations
      Add simple SoA (along with rant)
      Add some PP benchmarks
      Style change for is_prime -- no performance difference
      Speedup for PP is_prime and factor
      Speedup for powmod/mulmod (helps factor, isprime, etc.)
      Cleanup random_prime a little
      Speed up random_ndigit_prime a little for 9+ digits
      Adjust comments
      Remove old renamed file
      Forgot prototype -- could be cause of test failure
      Turn on bignum support for PP code
      Lots of bignum support
      Do a mod before power operations -- avoids fp exception for very large 
bases on small n
      Many changes for bignum support
      Test euler_phi for small values
      Note some bignum things that should be done
      Lots of bignum changes, new tests, update version number
      More bignum fun
      Benchmark both XS and front end
      Add BPSW primality test, hooray
      Miller Rabin returns 0 or 1 only.  Export strong Lucas pseudoprime 
      Add missing test file to MANIFEST
      Bigint enhancements
      Doc updates
      Full bigint support, add -bigint to import list to turn off
      Merge conflicts?
      Restore from $&^&$ up merge
      Update for older Perls and bigint
      Add tests for strong lucas pseudoprimes
      3x speedup for bigint factor and primality
      Redo random primes, add Maurer's algorithm.  random_ndigit_prime needs 
      Updates for portable bigints and random primes
      More random prime work
      More random prime changes
      Minor updates
      Tests for random primes, fix for random primes on 5.6.2
      Recommend Math::BigInt::GMP and try to use in tests
      more fun with bigints and random primes
      Use the MPU:GMP module if we can
      Fix an issue with random primes
      Minor GMP related change for performance and doc
      GMP and bigint stuff
      fix POD issue
      Work on factoring a little
      Factoring speedups
      Change %lu to use unsigned long
      Use GMP primes function.  Doc tweaks
      Update TODO, add Math::Big to performance
      Update performance number with Math::Primality estimate
      Merge branch 'master' of
      Strip out the prime_count and nth_prime bounds and approx from C code
      Minor updates for release
      Tweak native precision factoring sequence
      Tweaks, Dusart 2010 bounds, documentation overhaul
      Big documentation update for PP
      Check main::rand() existance at runtime
      Turn off threading tests for Cygwin
      Change exp2 to pow, and incorporate inverse into exponent
      Wrap inverse into exponent in Riemann Zeta evaluation
      Bump version number
      Compile issues, especially MSC
      Add a prototype, remove an unused variable
      rearrange math to keep precision in some cases
      Change tests for next/prev 0..3572 to do 2 tests instead of 7146.  Speeds 
up a lot, and in theory should give us the same debug info
      bigint / bignum changes
      Note the changes for today
      Add racing SQUFOF
      Racing SQUFOF & other UV factoring changes
      Turn off racing squfof in main routine
      Export RiemannZeta function
      Update versions for next release
      Call GMP prime_count if available
      Add prime_set_config, add assume_rh, use Schoenfeld bounds
      Remove done_testing()
      Some changes for valgrind -- nothing big
      Add primorial and pn_primorial
      Use long doubles for possible better precision
      Fix issue with string input just a little larger than ~0
      Allow trial_primes to be more intelligent instead of always forcing true 
trial division
      Better switch between segment and trial methods for very large end values
      If using the GMP module for primes(), convert the result to BigInts
      Initial implementation
      Add script
      Add Lucas, Fibonacci, and Palindromic primes, plus speedups
      Test harness for script, comparing to OEIS data
      Fix up primorial and pn_primorial for bigints
      Major rewrite of, and add more filters
      Small speedups
      Next round of mods
      More changes, and script test does multiple filters
      Recommend Math::BigInt::GMP -- it can speed things up a LOT with big 
      Enhancements to tests
      Minor issues with huge inputs
      Add Lucky primes, make Cuban primes via a generator instead of filter 
(hugely faster)
      Speed up powmod a tiny bit
      Use 2 MR bases for more numbers
      Rewrite p-1 factoring, enhance racing SQUFOF, switch to racing SQUFOF in 
      Simple primality proving added (the GMP code is much better)
      Add option to ensure all output has gone through primality proving
      Fix compiler warnings
      Enable Travis CI
      Changes for p-1 factoring
      Add and enhance examples, add bin/
      Add documentation for prime_set_config
      Fix prime_count bug (added to test suite), add Lehmer prime count
      Use Lehmer method for big prime counts
      Comments and a small speedup for Lehmer
      More Lehmer improvements (faster, lower memory)
      More Lehmer speedups and memory enhancements
      Don't run the 64-bit edge case on broken 5.6.2
      No timing messages from Lehmer, and reduce threshold since it's faster now
      Relax constraint on bignum version.  It works fine with 0.22
      Add AKS primality test
      Update some examples
      Skip the AKS tests on 32-bit machines.  They're way too slow in PP.
      Have nth_prime use Lehmer prime count on lower bound.  100x speedup for 
big numbers.
      Update documentation
      Fix prime count issue and make standalone.  Add Meissel method.
      Ready for next release
      Add 'verbose' config option
      Have verbose option set GMP verbosity also
      Increased precision for bignum zeta and R
      Update MR bases for deterministic tests
      Use references in for performance.  Lucky primes take less 
      Move mulmod, powmod, etc. to separate file.  A few changes.
      Let AKS in XS work with larger inputs.
      Split AKS out of isprime tests.  Extend AKS from halfword to fullword.
      Add jordan_totient, divisor_sum.  Slight speedup for euler_phi and 
      Streamline random prime test, add more testing for nbit and maurer random 
      Streamline some expensive tests, move bignum Zeta/R to separate file
      Changes file has test and zeta changes mentioned
      Skip 15+ digit tests on broken 5.6.2.  Workaround bug in Math::BigInt in 
extra tests.
      Fixup 5.6.2, and some li and Ei range cases
      Tweak MR test, add environment variables to disable XS and GMP
      Add PP Lehmer prime count, including nth_prime speedup.  Fix some 
no-XS-with-GMP issues.
      Speed up PP Lehmer by 10-100x at the expense of memory
      Fixes for various compile / test issues
      Update for release, and standardize infinity processing
      Modify tests to handle Win32 infinity also
      Missed an inf
      Fix 32-bit issue with lehmer
      Work around broken 64-bit Perl 5.6.2
      Use Math::MPFR if possible for Ei/li/Zeta/R functions.  Huge speedup and 
accuracy gains for BigFloats.
      Tests for primorial, jordan_totient, divisor_sum
      Make random_*_prime do bignums when passed Math::BigInt objects
      Random prime updates
      Major changes to random primes.  Return BigInts for big results on 
primorial and random primes.
      Update tests for new functions, and Perl 5.6.2 workarounds
      Revamp internal rand system for random primes
      Swap system/user rand
      Fix issue with Math::BigInt::GMP on 32-bit Win32
      Fix some horrible breakage on 32-bit
      Better R accuracy with multiple calls
      Remove an extra loop from PP M-R
      Work around randbits >= 32 on 32-bit system
      Perl 5.8.2 gets 12345**4 wrong, change to 12345*12345*12345*12345
      Don't use last bit of drand48
      MSC doesn't use inline.  In theory __inline should work.
      Update timings for prime_count
      Make sure we don't try to use really old versions of MPFR
      Very small optimization for PrimeArray.
      Lighten threads testing for normal case (helps some slower machines), add 
more for release testing
      Allow turning off MPFR.  Run travis tests on dynamic dependency 
      Install mpfr before Math::MPFR
      Speed up Travis CI
      Unroll inner loop of sieve for another 20% speedup
      Allow script to eval simple math expressions
      Allow an expression to eval to 0
      Silence perl critic for expression eval
      Revamp rand internals yet again.  Sadly also a rand API change.
      Update rand function in test - Win32 32-bit needs mod instead of and
      Update versions and dates for release
      Tweak rand setup a little
      Don't run the long AKS test on any 32-bit platform
      Fix old Solaris compilation
      Log some more bignum info to get a clue why old ActiveState's 
BigInt::Calc barfs
      Round the perfect power test, note its faults
      Add random_strong_prime, update to 0.18
      Travis test with all features as well as deselections
      Update MR bases
      Fix bignum / Calc issues (things turning into BigFloats)
      Add tests for is_provable_prime
      Fix more bignum issues
      Better test coverage
      More bignum and 5.6 changes
      Update MR bases
      Update M-R bases
      Modify validation to lower overhead
      Prepare for 0.19 release
      Speedup for PP AKS, turn off tests on 32-bit machines
      Change PP perfect square test
      New perfect power implementation
      Bump version for release
      Add function def to example
      Add circular primes to (OEIS 68652, also in Project Euler 
problem 35)
      Speedups for Pillai primes
      Minor tweaks
      Spelling corrections in documentation
      Add Euler totient range, speedup divisor_sum
      Switch to Bytes::Random::Secure
      New M-R bases
      Range Moebius function.  Fast Mertens function.
      Ranged mobius function
      Update documentation to reflect the change to Bytes::Random::Secure
      Faster Mertens
      Add Mangoldt function
      Performance enhancements
      Testing changes for release
      Final changes for release
      Remove Algorithm::Diff dependency, as it isn't used any more
      Totient and Mobius changes, move factor loop out of XS.xs
      Switch to pthreads condition variables
      Squash some compiler warnings
      Compiler warnings and coverage
      Put segment mutex back
      move scripts
      Turn thread tests on for Cygwin and NetBSD.  Add simple RiemannZeta test 
      Getting ready for release
      Optimizations for von Mangoldt function
      Merge Akron's fix to dates in Changes
      Slight doc change for moebius/phi/lambda/M
      Change XS Zeta code
      Update PP Zeta -- much better now
      Add consec int lcm, documentation changes
      Fix return value with consec int lcm and MPU::GMP
      Add binary search for nth_prime, for inputs > 2e11
      Minor updates
      Add Chebyshev theta and psi functions
      10x speedup for divisor_sum
      Test coverage and small AKS speedup
      Start to add LMO prime_count
      Change type of mobius return.  Some different ranged algorithms in 
      Move totient range to util.c, speed it up a little bit
      Fix divisor sum on bigints
      New data structure for phi(x,a): faster prime_count
      In-place phi(x,a) merge
      Minor updates for release
      Fix 32-bit issues
      Fix segmented euler_phi
      Some more speedups
      More lehmer tweaks
      Set smaller preseive with standalone primesieve
      Improvements for PP prime_count
      Minor updates for release
      Move a test into xt directory
      Add table sieve, fix off-by-one in Lehmer, change sieve/advanced 
transition in Lehmer
      Merge branch 'master' of
      Newest M-R bases
      Change to unified method for small is_prime, next_prime, prev_prime, 
      Add xt test to do exhaustive small is/next/prev tests
      Update for release
      Documentation tweaks
      Speed up p-1 stage 2
      New internal macro to loop a..b using primary sieve
      Forgot to skip one of the tests with broken 5.6.2
      Update for primesieve 4.2
      Documentation update, including a giant SEE ALSO section
      Tweak factoring and factor tests based on coverage analysis
      Documentation changes
      Speed up rsqufof a little, use for 19 dig semiprimes
      Allow turning on/off gnufactor or pari
      Travis-CI change in installation order
      Add large bases to pseudoprime tests
      Move the a=1 pbrent into XS.xs instead of factor.h
      Move to next version number
      Documentation updates
      Fix: Was checking wrong BigInt variable and loading a second backend.
      Primality verification (needs documentation)
      Remove Data::Dump used for debugging
      Add tests for verify_prime
      Work on pure perl factoring
      Add primality certificates, elliptic curve start
      Fix misspelled proof name
      PP: add simple ECM factoring and BLS75 primality proof
      Documentation formatting
      Projective ECM for pure Perl
      Primality proof updates
      Add GMP-ECPP verification example
      Tweak projective EC point
      Fixup for 5.6.2
      Allow to parse many MPU functions
      Move a couple of the bigger primality proofs to RELEASE_TESTING -- slow 
without GMP
      Fixes for final release
      Fix spelling error (RT 84782)
      Speedups for pure perl factoring of small numbers
      Fix filename of ecpp verification, add sage version
      Fix error with big aks inputs (order would roll over)
      Must compare n and q as bigints
      primality certificate edge cases
      Convenient primality proof random test
      Merge branch 'master' of
      Allow BLS75 theorem 7 n-1 proofs
      pure perl factoring tweaks
      Merge branch 'master' of
      Small speedup for composites in is_prob_prime/is_prime
      Increase coverage
      Remove dead code
      Add spelling test and do some spelling adjustments
      Add more test coverage
      Let accept +N as a second argument
      More test coverage
      More verbose/error output consistency for verify_prime.  Tests.
      Use XS initial validator
      Make is_prime go to is_prob_prime after initial tests
      New 3-base solution
      Adjust tests to work around Perl 5.6.2 quirks
      Push full primality test into PP from
      Invert XS/Perl relation for is_prime, is_prob_prime, next_prime, 
      Make sure test works on 32-bit platforms
      Rewrite PP Lucas code.  About same speed, but simpler.
      Updates for release, including docuemntation and direct C->MPU:GMP calls
      Minor updates for release
      More efficient ranged Moebius code
      Add forprimes multicall
      Backward compatibility changes around multicall
      Fix memory leak in forprimes.  Document it.
      Fix Win32 threading breakage
      Update primearray and add a simple iterator
      Document the prime iterator
      tests for forprimes and iterator
      Update for release
      Fix some multicall portability issues (5.8.2)
      Add new files to MANIFEST
      ranged moebius was depending on char being signed.  Fix.  Thanks Debian 
      segmented sieve infrastructure, and have forprimes use it.
      Speed up primality proof tests on non-64-bit machines
      Speed up primality proof tests on non-64-bit machines
      Add strong Lucas test
      Don't use MULTICALL yet -- memory leak
      Add two more probable prime tests
      Add standard Lucas test
      Transition some functions to forprimes
      Fixes for 5.6 (sigh)
      Make sure non-XS can use forprimes properly
      Update some benchmarks and examples
      Code comments about primality testing and the non-exported F-U test
      Fix prime_count_approx being really slow for > 10^36 without Math::MPFR
      Workaround for MSVC compiler
      Try to work around old Activestate crud
      Add Lucas sequence and have all 3 Lucas tests use it
      Change to submod and mulsubmod for better portability
      Fix a refcount GMP callback issue, and add test for it
      Remove unused variables, set reproducible random results in a benchmark
      Add F-U compositeness test, and tighted ECPP certificate conditions
      Use Data::Dump::dumpf
      Add lucas_sequence
      Add PP code and simple test for frobenius_underwood probable prime test
      Documentation updates
      Add braindead p+1 factoring
      Speedup for P=1,Q=-1 Lucas sequence, which is half the standard/Strong 
Lucas test cases
      Make sure n is odd to get exact results from lucas_sequence
      Update Lucas tests
      Almost extra strong lucas prps
      Cleanup is_prob_prime
      Rewrite some performance comparison text
      Turn on gcc's uint128 types if we have a new enough version
      Update some benchmarks
      Update todo list
      Update p+1 factoring, add to tests
      Combine lots of functions with common signatures
      fixup AES Lucas test
      Merge pull request #2 from dsteinbrunner/patch-1
      Clean up Lucas, update PP is_prime, remove an test func that got put in 
XS.xs, add documentation
      Changes file follows CPAN::Changes::Spec format
      Not all gcc targets support uint128, e.g. Atom
      Fix case of forprimes with begin = 6 returning 5, and add test
      signed chars fix for defined-out LMO function
      Tested multicall with 5.8, 5.10, 5.16, 5.17s, 5.18 -- looks good so just 
use it.
      Add cpanfile
      is_prime is faster now, so SophieGermain is over 2x faster
      INCOMPLETE BROKEN : Switching to new text proofs, part 1
      Add primality proving submodule
      Switch to new text proofs, part 2
      Add standalone verifier (from MPU::GMP)
      Small grammar updates
      Add x86_64 asm for addmod from Kruppa
      Add more limitations on __int128 use
      Add proof documentation to TODO list
      Update primality certificate documentation
      10-15% speedup for ranged totient internals
      Patch up silly MPU::GMP cert mistake
      Updates for random_nbit_prime and documentation
      Add random_proven_prime, modify random_nbit_prime
      Add carmichael_lambda; use F&T A2 for random_nbit_prime
      Turn off F&T A2, need to make sure top bit is set
      Update for new M-R base from Panasiuk and Izykowski
      Remove code for F&T A2 -- needs fundamental change to have nth bit set
      Add BLS75 paper to references list
      Add a couple more CPAN mirrors, as the Travis-CI one has lost data
      Redo mirrors
      Small updates for prime array
      Add output comments to primesarray bench
      Update a couple examples
      Speedup Maurer slightly by going straight to is_prob_prime with GMP
      Use MPU::GMP::pn_primorial if possible
      Add ifs to powmod initial mod; add verbose to
      Merge branch 'master' of
      Allow parallel phi sum by using critical section around phicache
      Add Pk_2 function, simplify some code
      Add speedup for divisor count
      Merge branch 'master' of
      Revised mulmod x86_64 asm, work with Wojciech Izykowski
      Merge branch 'master' of
      Move primality functions to new file.  Use Monty routines
      Primorial primes print a bit faster
      standardize variable names
      Add znorder function for multiplicative order
      Fix sluggish validation of AES increment for common cases
      Add Monty math for Frob-Underwood, AES Lucas, and one case for standard 
      Divisor sum with integer second arg
      Speedups for divisor_sum
      Montgomery reduction for all Lucas tests
      Perl 5.6 fixes
      Revamp input processing to accept bigints
      Tweak sieve to make more efficient for large bases
      Add prime iterator object
      Test for edge cases, fix some near-maxuv issues
      Use mpu method to get new oo iterator
      Minor cleanup
      ECPP verification: floor(2*sqrt(n)) instead of 2*floor(sqrt(n))
      Speedup for random_nbit_prime
      Make better comparisons for next/prev test
      Updates for release
      Add stopword for newest spellchecker
      Remove trailing whitespace
      Speedup lucas sequence => speedup BPSW test
      Dynamically load BRS; PP random_nbit_prime speedup
      Merge branch 'master' of
      Fix pure perl lucas sequence with Q=-1
      Redo benchmark section
      Add miller_rabin_random; add primality testing opinions to documentation
      Make factor consistent in scalar context
      Merge branch 'master' of
      Cache random function for less overhead
      Make sure strtoull is used for 64-bit when possible
      Adjust some benchmarks
      Merge branch 'master' of
      Remove all mirrors from travis config
      Simplify some of the randomness loop code
      Make Test::Warn a suggested dependency -- no longer required
      Only use TEST_REQUIRES with new enough MM
      Merge branch 'master' of
      delete TEST_REQUIRES after merging
      Update Changes
      Example for abundant, deficient, perfect numbers
      Tiny PP factor speedup
      Iterator object tests and fixes for next/prev prime behavior near native 
      Update iterator object value_to_i*
      Documentation update
      Updated LMO and Lehmer internals, switch to LMO
      Silence compiler warnings on 32-bit
      Little updates before release
      fix some prime count performance and openmp cases
      Add XS routine for ([p1,p2,p3],[e1,e2,e3]) return from factor
      Lucas sequence should return a bigint if arg is a bigint
      Add liousville, factor_exp, partitions.  all_factor includes 1,n.  
Internally use factor_exp in many places.
      Fix tests for all_factor, add liouville stopword
      Update partitions function
      Document partitions, tweak implementation for a little more speed
      Tests for partition()
      Add tests for liouville function
      Add tests for factor_exp and liouville
      Update version numbers
      Comment changes for part
      Zeta updates
      Zeta accuracy test in xt/
      Keep BigInt accuracy for Riemann Zeta/R
      Speedups for pure perl testing
      pondering pedantic perlcritic palaver
      exp_mangoldt in XS by default
      Improve test coverage
      Fix PP is_pseudoprime; Fix test issues
      Use Lehmer for small prime counts (below 8000 million), LMO for large
      Tweaks to LMO performance
      Hash->Scalar.  Add peek() and __iter__()
      Update with some more iterator examples
      Segment chebyshev_theta/phi, slight performance for ranged totient
      Tiny efficiency for Mertens
      Make sure large primorials don't overflow sigma_0
      Make sure we don't overflow large divisor counts on 32-bit machines
      Change C99 comments that snuck in
      Quote 0 in two tests, 5.8.2 use bigint treats 0 = NaN
      Make all tests run with 5.6.2 (with lots of skipping)
      Remove unused feature requirement
      Revise prime count table code, speedup 3.6M to 6M
      update for release
      Update for release
      Remove 64-bit test for 32-bit machines
      Update to next version number
      Switch small primes and lpf arrays to uint32_t
      Wrap large constant in UVCONST
      Add the extended prime count test
      For 64-bit, primei must be a UV instead of uint32_t
      auto bigint, round 1
      Tests hit by Math::BigInt::GMP bug.  Work around.
      Next try at consistent type upgrades for nth_prime_upper/lower
      Add commentary to measure_zeta_accuracy test
      Use XS prime count for small approx/lower/upper
      Changes for 32-bit
      32-bit fixes
      Extended LMO algorithm
      Put icbrt in util.h
      Move phi_total to sieve struct
      Adjust M factor: save a little memory, gain a bit of performance
      Update version number
      Just skip 64-bit testing on 5.6.2
      Remove two tests obsoleted by new BigInt behavior
      Add nth prime extra test
      Give the M adjustment a steeper slope
      Change nth_prime to use inverse Li+Corr instead of inverse R
      Restructure step 7 phi summation to streamline inner loop
      Protect against overflow
      Documentation updates
      Back off expensive PP prime count testing unless extended testing
      Thanks TravisCI -- need to count for the extra test when skipping
      Final updates for release
      Add some missing files to manifest
      Microsoft VC isn't C99, sigh
      fix LMO previous prime (sieve) when very near 32-bit limit
      Measured mu+lpf methods, adjusted comments
      A fix for prime counts > 18446744056529682436
      Comment changes
      Ensure M=alpha*n3 doesn't underflow
      Documentation change
      Add some 5.6.2 workarounds
      Microsoft compiler workarounds
      32-bit fixes, documentation updates
      Speedup for Legendre Pi (use small phi)
      LMO phi sieve is UV-word based instead of 32-bit-word bases
      Documentation updates; popcnt updates for LMO
      Remove trailing white space
      Have 32-bit use parallel bit count instead of 8-bit table
      Documentation updates
      _divisor_list in XS, use it.  Add simple forcomposites.
      first round of changes for factor(1)
      Second round of factor(0),factor(1) changes
      typo in all_factors alias
      Add fordivisors, forcomposites
      forcomposites using sieve
      Fix some compiler warnings
      forcomposites UVMAX edge cases
      Mapes => table for small phi
      Revert back to SvREFCNT_inc for old Perls
      Lehmer update cache settings
      New sieve code for finding segment composite inc/masks
      Performance changes for prime sieve
      Fix spelling error (RT 91562)
      Fix macro comparison, new benchmarks
      Line too long in synopsis
      Try to do fast word counts on 64-bit machines
      Some performance tweaks
      Remove dead code; convert count to segment start/next/end
      Convert segment_primes to segment start/next/end
      Speedup for basic sieve walking
      Fixup for earlier sieve count change
      Switch to primesieve 5.0
      Add sign multiply to caching phi for a=0,1
      Don't use GCC's builting popcount unless we have asm.  It can generate 
awful code.
      Small comment changes
      Use faster bit counting for sieve part of nth prime
      Fix _XS_legendre_phi for new table phi
      Use presieve/test for large segment bases.  Much faster and less memory.
      Wrap isqrt in #define so only included when needed
      Switch znorder to factoring Carmichael Lambda
      New factor_exp function
      Add kronecker, totient, carmichael_lambda, znprimroot
      Updated validate_int; znprimroot, carmichael_lambda, kronecker
      Add kronecker, znprimroot; XSify carmichael_lambda
      Move znorder to XS; add tests for znprimroot
      Fix PP test issues
      Huge speedup for znprimroot with non-cyclic input
      Allow string numbers to have a leading + sign
      Make sure PP znprimroot handles non-cyclic nputs quickly
      Speedups for Legendre/Meissel/Lehmer/LMOS old prime count routines
      Add tests for kronecker
      Merge pull request #4 from bulk88/master
      Merge branch 'master' of
      Add moebius/exp_mangoldt to util.c
      Shuffle functions between XS/Util/PP; significant XS changes
      Cleanup compiler warnings
      Change back to dTHX for now
      Hacky workaround to for MPU:GMP not understanding leading plusses
      Remove redundancy in inner loop of forprimes/forcomposites/fordivisors
      Merge pull request #5 from bulk88/master
      Move divisor_sum to XS; more XS interface cleanup
      Wrap large constants in UVCONST for 64-bit Perl on 32-bit machines
      More XS changes, plus small optimizations from bulk88
      Workaround for 5.6.2 PP
      Merge XS changes from bulk88
      Simplify my_svuv/my_sviv
      Merge branch 'master' of into 
      Modifications to previous merge
      Stop checking return of New/Renew and its propagations
      Don't compile Legendre/Meissel/Lehmer/LMOS prime counts by default
      Move factor_exp and divisors to XS->Perl, merge with factor
      Merge pull request #7 from bulk88/master
      Merge euler_phi and moebius XS
      More updates from bulk88 suggestions
      Next set of XS changes
      Input validation
      XS tweaks from bulk88
      Fixes for 5.6.2
      Use constant
      Input validation and better 5.6.2 support
      Fix threading argument
      Work around RT 49569 (Math::BigInt::FastCalc)
      Add Kronecker tests
      Add bigint tests for new functions
      Add tests for legendre_phi
      PP legendre phi wasn't making enough primes via public API
      nth_prime for legendre phi, not next_prime
      Add test for t/81-bignum.t no-clobber
      Update version number and date
      Move prime_count, nth_prime to XS
      More XS->Perl changes.  Add constant SV* returns for -1,0,1,2.
      Modify const SV for threads
      Another case of RT71548
      Change sieve macro advance to not read ahead (valgrind)
      Change comment to match current number of array items
      Add gcd function.  Fix forcomposites.  Fix test for GMP function 
      Refactor forprimes
      Use memcpy doubling -- fewer calls needed
      Go back to 200M threshold vs. 2M for looking in cache
      use constant with hash.  Saves a tiny bit of startup time
      Removed old SQUFOF code.  Faster is_perfect_square.  Streamline trial 
division pre-factoring.
      Tweaks to SQUFOF, pbrent, and strategy
      Speedup for palindromic primes
      Make is_bpsw_prime a first class function (though currently not exported)
      is_perfect_square doesn't use isqrt
      mapes -> tablephi.  Caching legendre phi
      Speed up some testing.  Move znorder to
      Add lcm.  Better PP legendre_phi.  Prune PP documentation.
      Try to use Pari in benchmark, but silently remove if not available
      Performance tweaks (small) for bigints
      Performance updates for no-GMP, focusing on making test suite run faster.
      Right number of extra tests, remove references to old _XS_next_prime
      First cut znlog
      Merge pull request #8 from bulk88/master
      Remove flags on get_cv
      Back off internal PP prime count in test, to help out very slow machines
      Double speed of AKS for small numbers on slow-modulo machines.  
poly_mod_mul checks for overflow in all terms are summed
      Make sure we can use  as an int
      Adjust use of constant to allow backward compatibility
      Merge branch 'master' of
      Small aks speedup
      Move PP AKS to only run with EXTENDED_TESTING.  It's horribly slow, a 
function nobody should practically use for anything, and they would run the C 
or GMP version anyway.
      Reduce some variable scoping
      Trim PP testing
      Use long double interface for the other three FP functions
      decl after code fix
      When doing XS bigint downgrade on old Perl, set the string
      Perl 5.6.2 workarounds for bigint downgrade
      Performance for PP, and a few pre-5.8 64-bit workarounds
      More tests run on 5.6.2 64-bit now
      Trim some tests, convert some proofs to new cert format, more tests work 
with pre-5.8 64-bit
      Turn off default irand in tests that don't care
      znlog tests and PP placeholder
      Switch more funcs to long double, and return results as NV
      Add clz and ctz
      More clz,ctz,log2floor changes
      Use new clz/ctz/log2floor
      Fix arguments for non-public *_factor functions
      Add ppport.h finally
      Merge bulk88 XS changes.  Add ppport.h use.
      small performance increase for next_prime
      Add simple (and likely buggy) Pollard Rho DLP
      Call Math::BigInt importer only if it hasn't been loaded already
      Changes for Math::BigInt::Pari (it doesn't play well with others)
      Remove the old -nobigint flag.  Better random ndigit for some old 
      Honor rounds in Fermat
      Fix stupid cpp typo
      Push some constants into a shared header file
      Use constants.h.  Simplify prev/next prime.  Simplify chebyshev 
functions.  Results in smaller object files.
      ranged totient faster and uses less memory
      Adjust PP testing to reflect some functions now being in XS
      Rearrange factor main loop
      remove _is_prime7, remove _XS_ header from a couple C functions
      Minor changes to examples
      Fix MSC support for ctz/clz, hopefully
      Simple Pari comparator (random values for functions in Pari and MPU)
      Pari's nth prime doesn't want 0
      Move jordan_totient to XS->PP from Util
      znorder and znlog adjustments for edge cases
      Updated Pari compare test
      LogarithmicIntegral using bignum and no-MPFR returns (1) better results, 
(2) rounded to a sane number of digits
      signed/unsigned warning
      Pari compare test done
      Adjust comments
      Adjust MANIFEST
      Make sure logl(constants) are only done once
      Simplify next_prime / prev_prime
      BigInt was upgrading to float in some cases
      Documentation updates
      Merge branch 'master' of
      Adjust factor recipe, 3-5% faster for large inputs.
      Adjust primes sub to reflect new segment sieve behavior
      Simplify primes()
      Fix 32-bit unsigned long issues
      Load PP and Math::BigInt only when used.  More work needed
      No validation means we weren't stripping weirdness from input bit counts.
      Move some functions from to util.c.  Faster, and reduces startup 
      Start work on separate PP front end
      Put back some PP validation, as it does bigint magic
      Bump version number
      More movement to PP front end
      More startup measurements
      More moving functions out of Util
      Clean up some random / proven primes
      Add some more terms to integer zeta table.  Speeds up prime_count_approx 
by 1.5x
      Small RiemannR speedup
      Some TODO items are done
      znlog update
      Remove the empty function call entirely for non-threads
      Update some examples
      Update examples and examples/README
      Add 1 to skipped 5.6.2 tests
      Move benchmarks to separate bench directory
      Adjust yafu tests
      Move last tests out of examples, into bench and xt
      Add Porter sequence example
      Update Changes
      Remove unused popcnt on 32-bit
      Minor documentation update
      Add some Project Euler examples
      Merge branch 'master' of
      First round: add is_perfect_power, is_perfect_square, is_perfect_cube
      Add todo about perfect power.  Going to change name.
      Merge branch 'master' of
      Change to is_power, still needs work
      is_power updates
      PP is_power with negative arguments
      Update some PE examples
      Trimming suggested by bulk88 (croak after New, move memset to just the 
needed branch)
      Wrap dlp_prho debugging vomit inside #ifdef DEBUG, as nobody else wants 
to see that detail
      Code movement
      Update PE 357 example
      Fix 5.6.2 issue with is_power
      euler_phi(0,n) had wrong [1] when n >= 100
      Add inverse totient example
      PP is_power(n,a) has to deal with 0 return unlike the split XS code
      Better is_power
      Merge with master
      Typo in bigint section
      More or less initial pbrent based on mulmod speed
      Add two more PE examples
      Add perfect power test in factoring
      Small speedup for is_power(x,2)
      Add a PE example
      Only test for squares and cubes in factor.  Lowers cost.
      Add xt ispower test and some more PE examples
      Slight speedup
      Small totient speedup
      Revised example of Math::Factor::XS::matches
      Add PE example
      Remove unused line
      Remove old test and print comment
      Spelling error: Dedekind
      Small change to PP znprimroot
      Doc updates
      Update version number
      Updates for AKS
      Small AKS update
      Try harder to use lgamma
      Add some threshold returns to protect vs. messed up rounding modes
      Custom lgamma so improved AKS works on all platforms
      ActiveState's gcc can't find builtins.  Pre-2005 compiler?
      Allow threading failures with diagnostics
      No MS intrinsics with MSC clang
      ispower test and 5.6.2 borkness
      Change NaN generation method
      Speedup for znprimroot
      Don't use Win32 intrins on WinCE
      fix sign warning in new znprimroot code
      32-bit with Math::BigInt::GMP causes havoc because of its RT71548
      Allow some author tests to run better on 32-bit Perl
      Partitions uses Math::BigInt only when needed
      logl -> log
      Bump version
      Don't use Math::BigInt::Pari for threading tests.  Math::Pari + threads = 
bad juju
      PP jordan totient, be more aggressive about BigInt args.  ActiveState 
      Add float.h to includes
      Bump version number
      Update PP F-U primality test
      Don't die in t/04 if platform doesn't have NaN (some activestate)
      Speedup for exp_mangoldt
      Documentation updates
      Speedup exp_mangoldt for large numbers -- primality + power detection 
instead of factoring
      Shawe-Taylor random provable primes.  No documentation.
      Shawe-Taylor random proven primes from FIPS 186-4
      Don't let ST random prime give up so easily
      random ST primes streamline the 32-bit case, allow 2-bit to return 2
      Update benchmark time
      Add coverage areas
      Add twin_prime_count
      Add twin_prime_count_approx
      give twin_prime_count a much denser table (92 vs. 5)
      Expand twin prime table
      Add nth_twin_prime
      Merge branch 'master' of
      Add PP nth_twin_prime
      AKS comments
      Small nth_twin_prime speedup.  xt test for twin_prime_count
      Add xt nth_twin_prime test
      Documentation tweaks
      Add new functions to tests
      Add PP twin_prime_count_approx
      Concerns about each
      Move a big hash to closure instead of sub local
      Improve test coverage
      Trim some PP tests for performance
      Inverse Riemann R for nth_prime_approx
      Add nth_twin_prime_approx, tighten twin_prime_count_approx
      Finish nth_twin_prime_approx
      Make sure nth_twin_prime goes to PP when the argument will overflow the C 
      Tighten nth_prime_{upper,lower}
      Edge case for legendre_phi
      speedups for legendre_phi with very large a
      Add one more big-a optimization to legendre_phi
      Add slightly faster ranged totient for start = 0
      Fix an old random_prime() bigint case.  No effect on proven, ndigit, or 
nbit random primes.
      More optimizations for euler_phi(0,n)
      Version comparison, make no warnings with test versions
      Don't do test for ST random prime without new Digest::SHA
      Fix typos
      Jordan totient even number shortcut
      Update precalc and timings
      improve twin prime approximations
      Add PP requirement for benchmark
      Better AKS testing, change to znorder from naive order
      Add numseqs example file, first version
      Add last sequences to numseqs examples
      Add PythagoreanHypots to numseqs example
      add valuation function
      croak with sane message when lucas_sequence given n < 2
      Add lucas_sequence tests
      New monty modinverse, nice primality speedup
      Update benchmark
      Improved code for mont_prod64
      Use 64-bit Montgomery math in primality tests even for 32-bit inputs
      Full trial divide of small factor inputs
      Another couple percent speedup for very small factor inputs
      Fix forcomposite with endpoint past max prime
      forcomposites, edge cases and performance
      Speedup for znprimroot
      Replace complicated invmod with simpler version that works properly for 
all n
      Bump version number
      Add invmod
      znorder arguments in PP code
      invmod edge cases, add tests
      is_pseudoprime / is_strong_pseudoprime
      Compiler warnings
      Simple forpart
      Update to forpart
      forpart now does restricted partitions
      forpart better interface, add docs, PP, tests
      Some forpart restriction speedups
      Validate input in PPFE for gcd, lcm, vecsum
      Add binomial(n,k)
      More aggressive binomial reduction
      forpart edge cases
      Make MPFR free cache after eint
      init entire array to ensure good behavior in n=0 case
      Extend binomial to negative arguments
      Full Kronenburg extension for binomial
      Work around old Math::BigInt bug
      Add Catalan sequence using binomial
      Move some examples to vecsum from List::Util::sum
      Allow GMP binomial
      Fix for old Math::BigInt and negative args
      binomial documentation update
      Add MephistoWaltz, PisanoPeriod, ProthNumbers
      Add native integer code to PP binomial
      whitespace and timings
      BM and BBS examples
      Allow better optimization for invmod and large modulus
      Add binomial, valuation, and invmod
      Updates for release
      PP next_prime much faster to return first bigint prime.  Huge speedup for 
      vecsum edge case: fix and add test
      Improve DLP (gcd before invmod)
      Further DLP rho improvements (speed up znlog)
      Add BSGS for znlog
      Add PP BSGS
      Use naive slot allocator in XS BSGS for nice speedup
      Push DLP Rho ahead of BSGS 16M
      Fix PP 0-return cases (e.g. a=1)
      More znlog speedups
      8-bit at a time inverse replacing 2-bit.
      Switch to unrolled montgomery inverse
      Alternate RiemannR calculation
      Alternate RiemannR, fix bignum Li
      BSGS no longer requires g to be invertible
      Add CRT to util, add Pohlig-Hellman, use PH in znlog
      Remove unused variables
      Add some tests from Pari bug trackers; fix PP znlog with a=0
      RiemannZeta and RiemannR updates
      Add gcdext and chinese, neither are finished yet
      Finish up gcdext
      Finish chinese
      Load Math::BigFloat when required in lehmer
      Streamline UV setting in forprimes hot loop
      Merge branch 'master' of
      Fiddle with sieve/partial-sieve crossover
      Bump segment sizes up.  Will want dynamic adjustment
      Dynamic segment sieve sizes; remove partial sieve
      Update csrand example
      Latest Montgomery product change from W. Izykowski
      Update performance numbers
      Fix type change in forprimes
      Update primality times; document weird closure-in-block case
      Updates to PP next/prev_prime,is_prime7,chebyshev_psi/theta
      Add release tests for documentation examples
      Revise PP sieve parsing, uses less memory
      Small changes for compilation
      PrimeArray examples added to t/33-examples.t
      work around bug in 5.20.0
      Partial sieve + test for small windows
      Skip znlog bigint test if not using GMP backend or EXTENDED_TESTING
      Speed PP pbrent and znlog
      znorder edge case; work around the usual Math::BigInt::GMP bug
      range and bigint edge cases
      Make sure examples test works with 32-bit
      Add one more digit to Zeta with MPFR
      More workarounds for borked 64-bit Perl
      nth_twin_prime_approx upper limit
      PP factor methods should skip basic factor when possible
      reftyped needs to handle negative numbers
      Back off random strong prime from 190 to 140 bits
      Use GMP gcdext and vecsum if available
      RiemannR with huge input should return inf
      weirdness with vecsum and the GMP hash
      PP chinese: push lcm*s into bigint loop.
      Bump strong prime back to 180 bits in test, for 5.6
      Add xt/chinese test, fix 64-bit chinese, PP addmod
      Speed up nth_twin_prime
      Update release version and date
      Update upper bound in comment
      Add MCE and serial versions of fibprime
      PP optimize for primes with small arguments
      SternDiatomic added
      Add tests for chinese with large inputs
      PP ranged moebius fencepost fix
      Moebius should try calling GMP directly
      Add GMP (via PP) processing options for euler_phi and jordan_totient
      znorder via PP; sort divisors with qsort
      reftyped should accept undef
      Fixup some synopsis examples
      csrand must have bits > 64
      Add Micali-Schnorr CSPRNG to examples/csrand
      Merge branch 'master' of
      Add Math::GMP version of CSPRNG example script
      Comment note that all the commented out tests have passed LMO
      Many synopsis test pass.
      Make sure BBS uses at least 3500 bits
      Add foroddcomposites
      Remove deprecated: miller_rabin and all_factors
      Merge branch 'master' of
      Very slight speedup for carmichael_lambda
      small factor and carmichael_lambda speedup
      TODO alternate prefix sums for LMO
      Add twin_primes()
      Simplify PP twin_primes() and make more efficient
      Tests for twin primes
      Fix forpart with amax=>0
      Add test for forpart with amax 0
      Small speedup for twin prime counting
      Update description
      Update comment
      Speed up for Emirps
      Add use_primeinc config option for random primes
      Use faster ranged totient when input is < 100 instead of = 0
      is_perfect_square uses isqrt
      Merge the 3 extra-strong-Lucas param selections into one static function
      Merge branch 'master' of
      HOLF premult; 10% speedup for 49 to 64 bit factoring
      Update version number
      Hacks to PP chinese for 5.6.2
      Merge branch 'master' of
      Comment about older perl 5.8s
      Add link to TODO
      Comment for vecsum
      Merge branch 'master' of
      Change znorder from Das to Cohen
      Tweak factoring parameters
      Fix AIX XLC long double issues
      Speed up isprime for small inputs on no-montgomery-math machines
      Tested List::Gen
      Add forcomb
      Add ntheory module alias
      Add forperm
      Add Algorithm::Combinatorics to see-also section
      Change from Heap's permutation to lexicographical
      PP versions of forcomb and forperm
      Add factorial; add tests for forcomb, forperm, factorial
      Add ecm_factor as option, finish adding is_bpsw_prime
      Update version number
      Test ecm in simple factoring test
      Version to 0.44_001
      Fixes for Win32 and older MPUGMP
      Redo PP forcomb loop, PP code returns one empty array for k=0.
      Unused additional Li implementaiton, may be useful for the PP code later
      forperm 0 and forcomb n.0 return an one empty list
      Fix spelling error in references
      Add Fibonacci pseudoprime test to lucas sequences test
      Only a few Fibonacci pseudoprimes if PP without GMP
      Update TODO
      Add basic Frobenius primality test
      Fix XS call-through for Frobenius
      Add Perrin pseudoprime, Frobenius has arguments
      crude PP lambertw function
      Documentation for Perrin and Frobenius
      Speedup for divisor_sum(n,k) with large k
      Add lambertw
      Cleanup for release tests
      Add PP Perrin and Frobenius primality tests
      Tests for more pseudoprimes and lambertw
      grammar fix in docs
      documentation for ntheory; provide modules
      Update docs
      Upper/lower bounds were having problems with bignums -- fix
      Last change ignored non-Math::BigFloats
      Add vecmin and vecmax functions
      Internal start on bernfrac
      Add bernfrac and bernreal
      Tests for bernfrac and bernreal
      Add caching of small values (under 100) to bernfrac
      Add Pi; look for better factorials in backend; add bernreal precision
      Update for Pi
      Update Pi
      Add Pi test
      Compiler warnings
      Tests for Pi
      Release tests
      Add simple tests for ntheory alias
      Add Pi to reference card
      Add vecprod
      Small changes for release
      Update version number
      Long double changes
      Update version number
      Fix forcomb with k=0, reading out of array bounds
      More fiddling with NaN, guessing at ActiveState
      Update version number
      Add MPUGMP to dep list automatically
      Fix memory leak in segment primes
      Redo bernfrac to make sure we load bigint before bigfloat
      simple PP stirling numbers
      Add Stirling numbers
      Workaround broken Math::BigInt::GMP, call GMP stirling
      Tests and docs for stirling
      Add PPFE front end for stirling
      Add simple product tree
      Edge cases for new PP vecprod
      Update version number
      Update Change date
      Another nan/infinity change
      Put Carp use in correct package
      Changes to ZetaBigFloat
      Add Pi*B_n variant of zeta calculation
      Speedup forpart with large nmin
      Documentation fixes
      Add prime gap verifier
      For non-objects that overflow UV, do string vecmin/vecmax
      Speedup for PP divisors
      Changes for 5.6.2
      Trim some time consuming tests
      Rewrite PP FU test, work around 5.6.2 segfault
      Small PP speedup
      Revert prime count approx test change
      Simplify a bit of zeta bigfloat
      Speedup for PP factoring: revised trial factor, small input Rho, more 
initial trial factoring
      Simplify divisors from factors
      Doc change to verify-primegaps example
      Improve test coverage
      PP: new trial factor, new primorial, update pbrent, update factor
      Update factor recipe to match ::PP
      Bump version number
      Allow different accuracy in ZetaBigFloat RiemannR
      Fix new Zeta accuracy for certain values
      divisor_sum changes
      Make is_pseudoprime act like is_strong_pseudoprime
      doc change for ntheory
      vecsum future note and PP shortcut
      Adjust Changes file
      Add hammingweight
      Release testing issues
      Add vecreduce function
      popcnt function for 32-bit
      Update Changes for release
      Rename popcount to fix NetBSD misbehavior
      is_power takes optional third argument
      Update is_power latest change
      Speedup for AKS with larger-than-half-word inputs
      Add AKS change to Changes
      Documentation fixes from Paul Underwood
      Merge branch 'master' of
      Standalone compilation
      Use bfloor instead of bint.  bint wasn't in pre-2014 Math::BigInt
      Bump version number
      standalone factor accepts multiple numbers per line
      next_prime / prev_prime do GMP/_to_bigint instead of PP code
      lucas_sequence via XS
      Add validation / bigint conversion to PP prev_prime and next_prime
      Move unexported ecm_factor out of root PM
      Move verify_cert old format conversion into
      Make sure bigint next/prev prime returns the input object type
      Test value needs to be 32-bit safe
      Allow negative n in is_power
      Don't use each on array in test can take oone argument (implied start = 0)
      Faster factoring
      Merge branch 'master' of
      Move uint128_t into ptypes.h
      Faster AKS on some machines
      Add is_mersenne_prime
      Use GMP lucas sequence if we are in PP is_mersenne_prime
      Fixup 5.8.x bugs
      Add is_mersenne_prime to ntheory doc
      Add large Perrin pseudoprime
      Fix negative is_power for defined a, still need a=0 case
      Fix ispower with negative input, add some tests
      is_mersenne_prime change to table for known values
      Remove unused variables
      Skip some expensive tests without GMP
      Move is_provable_prime to XS
      Update for release
      Initial lucasu and lucasv
      lucasu and lucasv
      Merge branch 'master' of
      Add lucasu/lucasv to Changes file
      Revise with some new functions
      Obnoxious Q=-1 speedup for lucasu/lucasv, need to find better solution
      Add Axler (2014) prime count bounds
      Comment changes in prime_count_approx comparisons
      Fix typo in extended test for mersenne primes
      Small speedup for p-1 factor
      Typo in example
      Typo in example comment
      Very small pbrent performance improvement
      Merge branch 'master' of
      Compiler warnings
      More pbrent for general factor search
      Retweak of recently changed factor parameters
      Catch some overflow conditions in lucasu/lucasv
      ispower with neg arguments, workaround Math::BigInt::Pari/old-perl bug
      Merge branch 'master' of
      Update version number
      Adjust PPFE for negative is_power inputs use lucasu/lucasv instead of hand calc
      Update version number
      Use Axler (2013) nth_prime bounds
      Add harmreal and harmfrac to PP as dev (needs work)
      harmfrac and harmreal for Harmonic numbers
      Speed up harmreal
      Allow prime count approx to work with string arguments
      harmreal will use MPFR if possible, and push some of its code to PP
      Fix a PP issue with nth_prime
      Use inverse prime count for nth prime in XS code
      Very simple vecextract
      Add Harmonic numbers
      nth_prime_lower/upper adjustments
      Start add sqrtint
      Ramanujan primes
      Tests and PP for ramanujan primes
      Update for sqrtint
      Adjust documentation
      New prime count bounds
      Add commented out Kulsha li code
      Update last checked Mersenne number
      znlog updates
      znlog use simple trial up to 10k (from 2k)
      detect cycles in dlp_trial, look at order for trial decisions
      Add single base hashed M-R for 2^32 primality
      Merge with main
      Fix for PP nth_prime on bigints
      Add documentation and PPFE for vecextract
      vecextract allow bigint and array ref second argument
      add sqrtl definitions
      Add missing threads macro use
      Add nth_ramanujan_prime
      Add is_ramanujan_prime
      Add new ramanujan functions to change list
      vecextract tests
      More efficient Ramanujan primes
      Speed up is_ramanujan_prime
      Remove unused function use
      Update last double-checked Mersenne exponent
      One more level of ramanujan prime upper
      Update for release
      Fix for old MPFR; faster PP sieving
      Add is_catalan_pseudoprime
      spelling, doc fixes for is_catalan_pseudoprime
      add base argument to foreach sieve macro
      lucas_seq with even n fixed for XS
      Even-n lucas_sequence fix for PP
      Use Aebi & Cairns result for semiprime catalan pseudoprimes
      Speedup for is_perrin_pseudoprime
      Fix global cleanup assert with MemFree object
      For memfree, just return if mutexes are not init.
      New code for Perrin pseudoprime pretests
      Allow squares to be Frobenius pseudoprimes
      Initial sum_primes and print_primes
      Fix compilation warnings for recent changes
      segments for sum_primes and print_primes
      Notice of sum_primes, print_primes functions
      Updates for sum_primes and print_primes including docs
      Comments about file handles for printing
      Update display less often, reduce timing precision displayed
      Add Khashin's Frobenius test
      Add some misc xt programs
      Fix undefined symbol
      Add PP version of Khashin Frobenius test
      Add a reset to prho and pbrent so they have better success
      Small optimization to Khashin code
      Update Mersenne limit with new GIMPS double check limit
      Update for release
      Changes date

David Steinbrunner (2):
      typo fix
      typo fixes

bulk88 (8):
      restore Win32 support
      remove dTHX usage
      don't set global SP to itself after vcallsubn
      various XSUB optimizations
      more XS tweaks
      non-XSUB tweaks
      fix declaration after code and redefinition warning for Win32
      XS tweaks

gregor herrmann (1):
      Imported Upstream version 0.51


No new revisions were added by this update.

Alioth's /usr/local/bin/git-commit-notice on 

Pkg-perl-cvs-commits mailing list

Reply via email to