[libmath-prime-util-perl] 15/16: Add tests for primearray, move MemFree, prepare for 0.08 release
Partha P. Mukherjee
ppm-guest at moszumanska.debian.org
Thu May 21 18:44:36 UTC 2015
This is an automated email from the git hooks/post-receive script.
ppm-guest pushed a commit to annotated tag v0.08
in repository libmath-prime-util-perl.
commit b2e0c520f408f31d08ef38b75929c0fcd91fbcdf
Author: Dana Jacobsen <dana at acm.org>
Date: Fri Jun 22 01:55:33 2012 -0600
Add tests for primearray, move MemFree, prepare for 0.08 release
---
Changes | 2 +-
MANIFEST | 2 +
README | 2 +-
lib/Math/Prime/Util.pm | 23 ++-------
lib/Math/Prime/Util/MemFree.pm | 81 ++++++++++++++++++++++++++++++
lib/Math/Prime/Util/PrimeArray.pm | 15 +++---
t/51-primearray.t | 103 ++++++++++++++++++++++++++++++++++++++
7 files changed, 200 insertions(+), 28 deletions(-)
diff --git a/Changes b/Changes
index 0d48120..1dd0b66 100644
--- a/Changes
+++ b/Changes
@@ -1,6 +1,6 @@
Revision history for Perl extension Math::Prime::Util.
-0.08 20 June 2012
+0.08 22 June 2012
- Added thread safety and tested good concurrency.
- Accuracy improvement and measurements for math functions.
- Remove simple sieve -- it wasn't being used, and was just around for
diff --git a/MANIFEST b/MANIFEST
index 22f2963..13bcdc0 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1,5 +1,6 @@
Changes
lib/Math/Prime/Util.pm
+lib/Math/Prime/Util/MemFree.pm
lib/Math/Prime/Util/PrimeArray.pm
LICENSE
Makefile.PL
@@ -50,6 +51,7 @@ t/18-functions.t
t/30-relations.t
t/31-threading.t
t/50-factoring.t
+t/51-primearray.t
t/90-release-perlcritic.t
t/91-release-pod-syntax.t
t/92-release-pod-coverage.t
diff --git a/README b/README
index 7d7b7f3..80a23bf 100644
--- a/README
+++ b/README
@@ -1,4 +1,4 @@
-Math::Prime::Util version 0.07
+Math::Prime::Util version 0.08
A set of utilities related to prime numbers. These include multiple sieving
methods, is_prime, prime_count, nth_prime, approximations and bounds for
diff --git a/lib/Math/Prime/Util.pm b/lib/Math/Prime/Util.pm
index d3873f8..e8e8805 100644
--- a/lib/Math/Prime/Util.pm
+++ b/lib/Math/Prime/Util.pm
@@ -5,7 +5,7 @@ use Carp qw/croak confess carp/;
BEGIN {
$Math::Prime::Util::AUTHORITY = 'cpan:DANAJ';
- $Math::Prime::Util::VERSION = '0.07';
+ $Math::Prime::Util::VERSION = '0.08';
}
# parent is cleaner, and in the Perl 5.10.1 / 5.12.0 core, but not earlier.
@@ -198,24 +198,7 @@ sub all_factors {
return @factors;
}
-# We use this object to let them control when memory is freed.
-package Math::Prime::Util::MemFree;
-use Carp qw/croak confess/;
-my $memfree_instances = 0;
-sub new {
- my $self = bless {}, shift;
- $memfree_instances++;
- return $self;
-}
-sub DESTROY {
- my $self = shift;
- confess "instances count mismatch" unless $memfree_instances > 0;
- Math::Prime::Util::prime_memfree if --$memfree_instances == 0;
- return;
-}
-package Math::Prime::Util;
-
-
+use Math::Prime::Util::MemFree;
1;
@@ -236,7 +219,7 @@ Math::Prime::Util - Utilities related to prime numbers, including fast sieves an
=head1 VERSION
-Version 0.07
+Version 0.08
=head1 SYNOPSIS
diff --git a/lib/Math/Prime/Util/MemFree.pm b/lib/Math/Prime/Util/MemFree.pm
new file mode 100644
index 0000000..052e1dd
--- /dev/null
+++ b/lib/Math/Prime/Util/MemFree.pm
@@ -0,0 +1,81 @@
+package Math::Prime::Util::MemFree;
+use strict;
+use warnings;
+
+BEGIN {
+ $Math::Prime::Util::MemFree::AUTHORITY = 'cpan:DANAJ';
+ $Math::Prime::Util::MemFree::VERSION = '0.08';
+}
+
+use base qw( Exporter );
+our @EXPORT_OK = qw( );
+our %EXPORT_TAGS = (all => [ @EXPORT_OK ]);
+
+
+use Math::Prime::Util;
+use Carp qw/carp croak confess/;
+
+my $memfree_instances = 0;
+sub new {
+ my $self = bless {}, shift;
+ $memfree_instances++;
+ return $self;
+}
+sub DESTROY {
+ my $self = shift;
+ confess "instances count mismatch" unless $memfree_instances > 0;
+ Math::Prime::Util::prime_memfree if --$memfree_instances == 0;
+ return;
+}
+
+1;
+
+__END__
+
+
+# ABSTRACT: An auto-free object for Math::Prime::Util
+
+=pod
+
+=head1 NAME
+
+Math::Prime::Util::MemFree - An auto-free object for Math::Prime::Util
+
+
+=head1 VERSION
+
+Version 0.08
+
+
+=head1 SYNOPSIS
+
+ use Math::Prime::Util;
+
+ {
+ my $mf = Math::Prime::Util::MemFree->new;
+ ... do things with Math::Prime::Util ...
+ }
+ # When the last object leaves scope, prime_memfree is called.
+
+
+=head1 DESCRIPTION
+
+This is a more robust way of making sure any cached memory is freed, as it
+will be handled by the last C<MemFree> object leaving scope. This means if
+your routines were inside an eval that died, things will still get cleaned up.
+If you call another function that uses a MemFree object, the cache will stay
+in place because you still have an object.
+
+
+=head1 AUTHORS
+
+Dana Jacobsen E<lt>dana at acm.orgE<gt>
+
+
+=head1 COPYRIGHT
+
+Copyright 2012 by Dana Jacobsen E<lt>dana at acm.orgE<gt>
+
+This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
+
+=cut
diff --git a/lib/Math/Prime/Util/PrimeArray.pm b/lib/Math/Prime/Util/PrimeArray.pm
index af57788..cbcd10f 100644
--- a/lib/Math/Prime/Util/PrimeArray.pm
+++ b/lib/Math/Prime/Util/PrimeArray.pm
@@ -4,7 +4,7 @@ use warnings;
BEGIN {
$Math::Prime::Util::PrimeArray::AUTHORITY = 'cpan:DANAJ';
- $Math::Prime::Util::PrimeArray::VERSION = '0.07';
+ $Math::Prime::Util::PrimeArray::VERSION = '0.08';
}
# parent is cleaner, and in the Perl 5.10.1 / 5.12.0 core, but not earlier.
@@ -14,7 +14,7 @@ our @EXPORT_OK = qw( );
our %EXPORT_TAGS = (all => [ @EXPORT_OK ]);
-use Math::Prime::Util qw/nth_prime nth_prime_upper primes/;
+use Math::Prime::Util qw/nth_prime nth_prime_upper primes prime_precalc/;
use Tie::Array;
use Carp qw/carp croak confess/;
@@ -40,6 +40,7 @@ sub STORE { carp "You cannot write to the prime array"; }
sub DELETE { carp "You cannot write to the prime array"; }
sub STORESIZE { carp "You cannot write to the prime array"; }
sub EXISTS { 1 }
+#sub EXTEND { my $self = shift; my $count = shift; prime_precalc($count); }
sub EXTEND { 1 }
sub FETCHSIZE { 0x7FFF_FFFF } # Even on 64-bit
# Simple FETCH:
@@ -47,7 +48,8 @@ sub FETCHSIZE { 0x7FFF_FFFF } # Even on 64-bit
sub FETCH {
my $self = shift;
my $index = shift;
- # TODO: negative index?
+ # We actually don't get negative indices -- they get turned into big numbers
+ croak "Negative index given to prime array" if $index < 0;
$index += $self->{SHIFTINDEX}; # take into account any shifts
if ( ($index < $self->{BEG_INDEX}) || ($index > $self->{END_INDEX}) ) {
# We're going to get a chunk of primes starting 1000 before the one
@@ -107,7 +109,7 @@ Math::Prime::Util::PrimeArray - A tied array for primes
=head1 VERSION
-Version 0.07
+Version 0.08
=head1 SYNOPSIS
@@ -199,11 +201,12 @@ Summing the first 10M primes via walking the array:
4s 365 MB $sum += $_ for @{primes(nth_prime(10_000_000))};
2m 2 MB Math::Prime::Util::PrimeArray
85m 2 MB Math::NumSeq::Primes
- >2048 MB Math::Primes::TiedArray (extend 1k)
+ >5000 MB Math::Primes::TiedArray (extend 1k)
Using L<Math::Prime::Util> directly in a naive fashion uses lots of memory,
but is extremely fast. Sieving segments at a time would control the memory
-use, which is one thing the C<PrimeArray> tie is trying to do for you.
+use, which is one thing the C<PrimeArray> tie is trying to do for you (but
+adds more inefficiency than is ideal).
L<Math::NumSeq::Primes> offers an iterator alternative, and works quite well
for reasonably small numbers. It does not, however, support random access.
diff --git a/t/51-primearray.t b/t/51-primearray.t
new file mode 100644
index 0000000..766d519
--- /dev/null
+++ b/t/51-primearray.t
@@ -0,0 +1,103 @@
+#!/usr/bin/env perl
+use strict;
+use warnings;
+
+use Test::More;
+use Math::Prime::Util::PrimeArray;
+
+# From List::Util
+sub shuffle (@) {
+ my @a=\(@_);
+ my $n;
+ my $i=@_;
+ map {
+ $n = rand($i--);
+ (${$a[$n]}, $a[$n] = $a[$i])[0];
+ } @_;
+}
+
+my @small_primes = qw/
+2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71
+73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173
+179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281
+283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409
+419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541
+547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659
+661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809
+811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941
+947 953 967 971 977 983 991 997 1009 1013 1019 1021 1031 1033 1039 1049 1051 1061 1063 1069
+1087 1091 1093 1097 1103 1109 1117 1123 1129 1151 1153 1163 1171 1181 1187 1193 1201 1213 1217 1223
+1229 1231 1237 1249 1259 1277 1279 1283 1289 1291 1297 1301 1303 1307 1319 1321 1327 1361 1367 1373
+1381 1399 1409 1423 1427 1429 1433 1439 1447 1451 1453 1459 1471 1481 1483 1487 1489 1493 1499 1511
+1523 1531 1543 1549 1553 1559 1567 1571 1579 1583 1597 1601 1607 1609 1613 1619 1621 1627 1637 1657
+1663 1667 1669 1693 1697 1699 1709 1721 1723 1733 1741 1747 1753 1759 1777 1783 1787 1789 1801 1811
+1823 1831 1847 1861 1867 1871 1873 1877 1879 1889 1901 1907 1913 1931 1933 1949 1951 1973 1979 1987
+1993 1997 1999 2003 2011 2017 2027 2029 2039 2053 2063 2069 2081 2083 2087 2089 2099 2111 2113 2129
+2131 2137 2141 2143 2153 2161 2179 2203 2207 2213 2221 2237 2239 2243 2251 2267 2269 2273 2281 2287
+2293 2297 2309 2311 2333 2339 2341 2347 2351 2357 2371 2377 2381 2383 2389 2393 2399 2411 2417 2423
+2437 2441 2447 2459 2467 2473 2477 2503 2521 2531 2539 2543 2549 2551 2557 2579 2591 2593 2609 2617
+2621 2633 2647 2657 2659 2663 2671 2677 2683 2687 2689 2693 2699 2707 2711 2713 2719 2729 2731 2741
+2749 2753 2767 2777 2789 2791 2797 2801 2803 2819 2833 2837 2843 2851 2857 2861 2879 2887 2897 2903
+2909 2917 2927 2939 2953 2957 2963 2969 2971 2999 3001 3011 3019 3023 3037 3041 3049 3061 3067 3079
+3083 3089 3109 3119 3121 3137 3163 3167 3169 3181 3187 3191 3203 3209 3217 3221 3229 3251 3253 3257
+3259 3271 3299 3301 3307 3313 3319 3323 3329 3331 3343 3347 3359 3361 3371 3373 3389 3391 3407 3413
+3433 3449 3457 3461 3463 3467 3469 3491 3499 3511 3517 3527 3529 3533 3539 3541 3547 3557 3559 3571
+/;
+
+my %test_indices = (
+ 377 => 2593,
+ 1999 => 17389,
+ 4500 => 43063,
+ 4999 => 48611,
+ 15678 => 172157,
+ 30107 => 351707,
+ 78901 => 1005413,
+ 123456 => 1632913,
+);
+
+
+plan tests => 1 + (3*scalar @small_primes) + 2 + scalar(keys %test_indices) + 8;
+
+{
+ my @primes; tie @primes, 'Math::Prime::Util::PrimeArray';
+
+ # Random
+ my @order = shuffle (0 .. $#small_primes);
+ foreach my $index (@order) {
+ is($primes[$index], $small_primes[$index], "primes[$index] == $small_primes[$index]");
+ }
+
+ # Forwards and backwards
+ foreach my $index (0 .. $#small_primes) {
+ my $rindex = $#small_primes - $index;
+ is($primes[$index], $small_primes[$index], "primes[$index] == $small_primes[$index]");
+ is($primes[$rindex], $small_primes[$rindex], "primes[$rindex] == $small_primes[$rindex]");
+ }
+}
+
+{
+ my @primes; tie @primes, 'Math::Prime::Util::PrimeArray';
+ is_deeply( [@primes[0..50]], [@small_primes[0..50]], "51 primes using array slice" );
+ is_deeply( [sort {$a<=>$b} @primes[shuffle (0 .. $#small_primes)]], \@small_primes, "random array slice of small primes" );
+}
+
+{
+ my @primes; tie @primes, 'Math::Prime::Util::PrimeArray';
+ while (my($n, $pn) = each(%test_indices)) {
+ is( $primes[$n], $pn, "primes[$n] == $pn" );
+ }
+}
+
+{
+ my @primes; tie @primes, 'Math::Prime::Util::PrimeArray';
+ is( shift @primes, 2, "shift 2");
+ is( shift @primes, 3, "shift 3");
+ is( shift @primes, 5, "shift 5");
+ is( shift @primes, 7, "shift 7");
+ is( shift @primes, 11, "shift 11");
+ is( $primes[0], 13, "13 after shifts");
+ unshift @primes, 1;
+ is( $primes[0], 11, "11 after unshift");
+ unshift @primes, 3;
+ is( $primes[0], 3, "3 after unshift 3");
+}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-perl/packages/libmath-prime-util-perl.git
More information about the Pkg-perl-cvs-commits
mailing list