r20919 - in /branches/upstream/libmath-round-perl/current: Changes MANIFEST META.yml README Round.pm test.pl
gregoa at users.alioth.debian.org
gregoa at users.alioth.debian.org
Tue Jun 10 18:30:13 UTC 2008
Author: gregoa
Date: Tue Jun 10 18:30:12 2008
New Revision: 20919
URL: http://svn.debian.org/wsvn/?sc=1&rev=20919
Log:
Load /tmp/perl/Math-Round-0.06/ into
branches/upstream/libmath-round-perl/current.
Added:
branches/upstream/libmath-round-perl/current/META.yml
Modified:
branches/upstream/libmath-round-perl/current/Changes (contents, props changed)
branches/upstream/libmath-round-perl/current/MANIFEST
branches/upstream/libmath-round-perl/current/README
branches/upstream/libmath-round-perl/current/Round.pm (contents, props changed)
branches/upstream/libmath-round-perl/current/test.pl (props changed)
Modified: branches/upstream/libmath-round-perl/current/Changes
URL: http://svn.debian.org/wsvn/branches/upstream/libmath-round-perl/current/Changes?rev=20919&op=diff
==============================================================================
--- branches/upstream/libmath-round-perl/current/Changes (original)
+++ branches/upstream/libmath-round-perl/current/Changes Tue Jun 10 18:30:12 2008
@@ -9,12 +9,17 @@
0.03 Mon Sep 17 10:34:40 2001
- Now using a value for one-half that is slightly larger than
0.5, to thwart the floating-point units. Thanks to Paul
- Rohwer (pauldrohwer at yahoo.com) for pointing this out.
+ Rohwer for pointing this out.
0.04 Mon Mar 4 11:33:15 2002
- Added nearest_ceil and nearest_floor at the suggestion of
- Charlie Kim (cckim at stanford.edu).
+ Charlie Kim (Stanford).
0.05 Mon Apr 22 10:07:09 2002
- Added nlowmult and nhimult at the suggestion of Tielman
- de Villiers (tjdevil at bondnet.co.za).
+ de Villiers.
+
+0.06 Wed Nov 29 20:29:08 2006
+ - Streamlined the code. Thanks to Richard Jelinek of PetaMem.
+ - Made $half a package variable. Thanks to Ruud H. G. van Tol
+ for pointing out some peculiarities of the rounding.
Propchange: branches/upstream/libmath-round-perl/current/Changes
------------------------------------------------------------------------------
svn:executable = *
Modified: branches/upstream/libmath-round-perl/current/MANIFEST
URL: http://svn.debian.org/wsvn/branches/upstream/libmath-round-perl/current/MANIFEST?rev=20919&op=diff
==============================================================================
--- branches/upstream/libmath-round-perl/current/MANIFEST (original)
+++ branches/upstream/libmath-round-perl/current/MANIFEST Tue Jun 10 18:30:12 2008
@@ -4,3 +4,4 @@
README
Round.pm
test.pl
+META.yml Module meta-data (added by MakeMaker)
Added: branches/upstream/libmath-round-perl/current/META.yml
URL: http://svn.debian.org/wsvn/branches/upstream/libmath-round-perl/current/META.yml?rev=20919&op=file
==============================================================================
--- branches/upstream/libmath-round-perl/current/META.yml (added)
+++ branches/upstream/libmath-round-perl/current/META.yml Tue Jun 10 18:30:12 2008
@@ -1,0 +1,10 @@
+# http://module-build.sourceforge.net/META-spec.html
+#XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX#
+name: Math-Round
+version: 0.06
+version_from: Round.pm
+installdirs: site
+requires:
+
+distribution_type: module
+generated_by: ExtUtils::MakeMaker version 6.17
Modified: branches/upstream/libmath-round-perl/current/README
URL: http://svn.debian.org/wsvn/branches/upstream/libmath-round-perl/current/README?rev=20919&op=diff
==============================================================================
--- branches/upstream/libmath-round-perl/current/README (original)
+++ branches/upstream/libmath-round-perl/current/README Tue Jun 10 18:30:12 2008
@@ -26,6 +26,7 @@
==============
Version 0.04: Added nearest_ceil and nearest_floor.
Version 0.05: Added nlowmult and nhimult.
+Version 0.06: Streamlined the code.
How to Install
==============
Modified: branches/upstream/libmath-round-perl/current/Round.pm
URL: http://svn.debian.org/wsvn/branches/upstream/libmath-round-perl/current/Round.pm?rev=20919&op=diff
==============================================================================
--- branches/upstream/libmath-round-perl/current/Round.pm (original)
+++ branches/upstream/libmath-round-perl/current/Round.pm Tue Jun 10 18:30:12 2008
@@ -1,365 +1,324 @@
-package Math::Round;
-
-use strict;
-use POSIX;
-use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
-
-require Exporter;
-
- at ISA = qw(Exporter AutoLoader);
- at EXPORT = qw(round nearest);
- at EXPORT_OK = qw(round nearest round_even round_odd round_rand
- nearest_ceil nearest_floor nearest_rand
- nlowmult nhimult );
-$VERSION = '0.05';
-
-%EXPORT_TAGS = ( all => [ @EXPORT_OK ] );
-
-#--- Determine what value to use for "one-half". Because of the
-#--- perversities of floating-point hardware, we must use a value
-#--- slightly larger than 1/2. We accomplish this by determining
-#--- the bit value of 0.5 and increasing it by a small amount in a
-#--- lower-order byte. Since the lowest-order bits are still zero,
-#--- the number is mathematically exact.
-
-my $halfhex = unpack('H*', pack('d', 0.5));
-if (substr($halfhex,0,2) ne '00' && substr($halfhex, -2) eq '00') {
- #--- It's big-endian.
- substr($halfhex, -4) = '1000';
-} else {
- #--- It's little-endian.
- substr($halfhex, 0,4) = '0010';
-}
-
-my $half = unpack('d',pack('H*', $halfhex));
-
-sub round {
- my $x;
- my @res = ();
- foreach $x (@_) {
- if ($x >= 0) {
- push @res, POSIX::floor($x + $half);
- } else {
- push @res, POSIX::ceil($x - $half);
- }
- }
- return (wantarray) ? @res : $res[0];
-}
-
-sub round_even {
- my $x;
- my @res = ();
- foreach $x (@_) {
- my ($sign, $in, $fr) = _sepnum($x);
- if ($fr == 0.5) {
- push @res, $sign * (($in % 2 == 0) ? $in : $in + 1);
- } else {
- push @res, $sign * POSIX::floor(abs($x) + $half);
- }
- }
- return (wantarray) ? @res : $res[0];
-}
-
-sub round_odd {
- my $x;
- my @res = ();
- foreach $x (@_) {
- my ($sign, $in, $fr) = _sepnum($x);
- if ($fr == 0.5) {
- push @res, $sign * (($in % 2 == 1) ? $in : $in + 1);
- } else {
- push @res, $sign * POSIX::floor(abs($x) + $half);
- }
- }
- return (wantarray) ? @res : $res[0];
-}
-
-sub round_rand {
- my $x;
- my @res = ();
- foreach $x (@_) {
- my ($sign, $in, $fr) = _sepnum($x);
- if ($fr == 0.5) {
- push @res, $sign * ((rand(4096) < 2048) ? $in : $in + 1);
- } else {
- push @res, $sign * POSIX::floor(abs($x) + $half);
- }
- }
- return (wantarray) ? @res : $res[0];
-}
-
-#--- Separate a number into sign, integer, and fractional parts.
-#--- Return as a list.
-sub _sepnum {
- my $x = shift;
- my ($sign, $i);
- $sign = ($x >= 0) ? 1 : -1;
- $x = abs($x);
- $i = int($x);
- return ($sign, $i, $x - $i);
-}
-
-#------ "Nearest" routines (round to a multiple of any number)
-
-sub nearest {
- my ($targ, @inputs) = @_;
- my @res = ();
- my $x;
-
- $targ = abs($targ) if $targ < 0;
- foreach $x (@inputs) {
- if ($x >= 0) {
- push @res, $targ * int(($x + $half * $targ) / $targ);
- } else {
- push @res, $targ * POSIX::ceil(($x - $half * $targ) / $targ);
- }
- }
- return (wantarray) ? @res : $res[0];
-}
-
-# In the next two functions, the code for positive and negative numbers
-# turns out to be the same. For negative numbers, the technique is not
-# exactly obvious; instead of floor(x+0.5), we are in effect taking
-# ceiling(x-0.5).
-
-sub nearest_ceil {
- my ($targ, @inputs) = @_;
- my @res = ();
- my $x;
-
- $targ = abs($targ) if $targ < 0;
- foreach $x (@inputs) {
- push @res, $targ * POSIX::floor(($x + $half * $targ) / $targ);
- }
- return (wantarray) ? @res : $res[0];
-}
-
-sub nearest_floor {
- my ($targ, @inputs) = @_;
- my @res = ();
- my $x;
-
- $targ = abs($targ) if $targ < 0;
- foreach $x (@inputs) {
- push @res, $targ * POSIX::ceil(($x - $half * $targ) / $targ);
- }
- return (wantarray) ? @res : $res[0];
-}
-
-sub nearest_rand {
- my ($targ, @inputs) = @_;
- my @res = ();
- my $x;
-
- $targ = abs($targ) if $targ < 0;
- foreach $x (@inputs) {
- my ($sign, $in, $fr) = _sepnear($x, $targ);
- if ($fr == 0.5 * $targ) {
- push @res, $sign * $targ * ((rand(4096) < 2048) ? $in : $in + 1);
- } else {
- push @res, $sign * $targ * int((abs($x) + $half * $targ) / $targ);
- }
- }
- return (wantarray) ? @res : $res[0];
-}
-
-#--- Next lower multiple
-sub nlowmult {
- my ($targ, @inputs) = @_;
- my @res = ();
- my $x;
-
- $targ = abs($targ) if $targ < 0;
- foreach $x (@inputs) {
- push @res, $targ * POSIX::floor($x / $targ);
- }
- return (wantarray) ? @res : $res[0];
-}
-
-#--- Next higher multiple
-sub nhimult {
- my ($targ, @inputs) = @_;
- my @res = ();
- my $x;
-
- $targ = abs($targ) if $targ < 0;
- foreach $x (@inputs) {
- push @res, $targ * POSIX::ceil($x / $targ);
- }
- return (wantarray) ? @res : $res[0];
-}
-
-#--- Separate a number into sign, "integer", and "fractional" parts
-#--- for the 'nearest' calculation. Return as a list.
-sub _sepnear {
- my ($x, $targ) = @_;
- my ($sign, $i);
- $sign = ($x >= 0) ? 1 : -1;
- $x = abs($x);
- $i = int($x / $targ);
- return ($sign, $i, $x - $i*$targ);
-}
-
-1;
-
-__END__
-
-=head1 NAME
-
-Math::Round - Perl extension for rounding numbers
-
-=head1 SYNOPSIS
-
- use Math::Round qw(...those desired... or :all);
-
- $rounded = round($scalar);
- @rounded = round(LIST...);
- $rounded = nearest($target, $scalar);
- @rounded = nearest($target, LIST...);
-
- # and other functions as described below
-
-=head1 DESCRIPTION
-
-B<Math::Round> supplies functions that will round numbers in different
-ways. The functions B<round> and B<nearest> are exported by
-default; others are available as described below. "use ... qw(:all)"
-exports all functions.
-
-=head1 FUNCTIONS
-
-=over 2
-
-=item B<round> LIST
-
-Rounds the number(s) to the nearest integer. In scalar context,
-returns a single value; in list context, returns a list of values.
-Numbers that are halfway between two integers are rounded
-"to infinity"; i.e., positive values are rounded up (e.g., 2.5
-becomes 3) and negative values down (e.g., -2.5 becomes -3).
-
-=item B<round_even> LIST
-
-Rounds the number(s) to the nearest integer. In scalar context,
-returns a single value; in list context, returns a list of values.
-Numbers that are halfway between two integers are rounded to the
-nearest even number; e.g., 2.5 becomes 2, 3.5 becomes 4, and -2.5
-becomes -2.
-
-=item B<round_odd> LIST
-
-Rounds the number(s) to the nearest integer. In scalar context,
-returns a single value; in list context, returns a list of values.
-Numbers that are halfway between two integers are rounded to the
-nearest odd number; e.g., 3.5 becomes 3, 4.5 becomes 5, and -3.5
-becomes -3.
-
-=item B<round_rand> LIST
-
-Rounds the number(s) to the nearest integer. In scalar context,
-returns a single value; in list context, returns a list of values.
-Numbers that are halfway between two integers are rounded up or
-down in a random fashion. For example, in a large number of trials,
-2.5 will become 2 half the time and 3 half the time.
-
-=item B<nearest> TARGET, LIST
-
-Rounds the number(s) to the nearest multiple of the target value.
-TARGET must be positive.
-In scalar context, returns a single value; in list context, returns
-a list of values. Numbers that are halfway between two multiples
-of the target will be rounded to infinity. For example:
-
- nearest(10, 44) yields 40
- nearest(10, 46) 50
- nearest(10, 45) 50
- nearest(25, 328) 325
- nearest(.1, 4.567) 4.6
- nearest(10, -45) -50
-
-=item B<nearest_ceil> TARGET, LIST
-
-Rounds the number(s) to the nearest multiple of the target value.
-TARGET must be positive.
-In scalar context, returns a single value; in list context, returns
-a list of values. Numbers that are halfway between two multiples
-of the target will be rounded to the ceiling, i.e. the next
-algebraically higher multiple. For example:
-
- nearest_ceil(10, 44) yields 40
- nearest_ceil(10, 45) 50
- nearest_ceil(10, -45) -40
-
-=item B<nearest_floor> TARGET, LIST
-
-Rounds the number(s) to the nearest multiple of the target value.
-TARGET must be positive.
-In scalar context, returns a single value; in list context, returns
-a list of values. Numbers that are halfway between two multiples
-of the target will be rounded to the floor, i.e. the next
-algebraically lower multiple. For example:
-
- nearest_floor(10, 44) yields 40
- nearest_floor(10, 45) 40
- nearest_floor(10, -45) -50
-
-=item B<nearest_rand> TARGET, LIST
-
-Rounds the number(s) to the nearest multiple of the target value.
-TARGET must be positive.
-In scalar context, returns a single value; in list context, returns
-a list of values. Numbers that are halfway between two multiples
-of the target will be rounded up or down in a random fashion.
-For example, in a large number of trials, C<nearest(10, 45)> will
-yield 40 half the time and 50 half the time.
-
-=item B<nlowmult> TARGET, LIST
-
-Returns the next lower multiple of the number(s) in LIST.
-TARGET must be positive.
-In scalar context, returns a single value; in list context, returns
-a list of values. Numbers that are between two multiples of the
-target will be adjusted to the nearest multiples of LIST that are
-algebraically lower. For example:
-
- nlowmult(10, 44) yields 40
- nlowmult(10, 46) 40
- nlowmult(25, 328) 325
- nlowmult(.1, 4.567) 4.5
- nlowmult(10, -41) -50
-
-=item B<nhimult> TARGET, LIST
-
-Returns the next higher multiple of the number(s) in LIST.
-TARGET must be positive.
-In scalar context, returns a single value; in list context, returns
-a list of values. Numbers that are between two multiples of the
-target will be adjusted to the nearest multiples of LIST that are
-algebraically higher. For example:
-
- nhimult(10, 44) yields 50
- nhimult(10, 46) 50
- nhimult(25, 328) 350
- nhimult(.1, 4.512) 4.6
- nhimult(10, -49) -40
-
-=back
-
-=head1 STANDARD FLOATING-POINT DISCLAIMER
-
-Floating-point numbers are, of course, a rational subset of the real
-numbers, so calculations with them are not always exact. In order to
-avoid surprises because of this, these routines use a value for
-one-half that is very slightly larger than 0.5. Nevertheless,
-if the numbers to be rounded are stored as floating-point, they will
-be subject, as usual, to the mercies of your hardware, your C
-compiler, etc. Thus, numbers that are supposed to be halfway between
-two others may be stored in a slightly different way and thus behave
-surprisingly.
-
-=head1 AUTHOR
-
-Math::Round was written by Geoffrey Rommel E<lt>GROMMEL at cpan.orgE<gt>
-in October 2000.
-
-=cut
+package Math::Round;
+
+use strict;
+use POSIX;
+use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
+
+require Exporter;
+
+ at ISA = qw(Exporter AutoLoader);
+ at EXPORT = qw(round nearest);
+ at EXPORT_OK = qw(round nearest round_even round_odd round_rand
+ nearest_ceil nearest_floor nearest_rand
+ nlowmult nhimult );
+$VERSION = '0.06';
+
+%EXPORT_TAGS = ( all => [ @EXPORT_OK ] );
+
+#--- Default value for "one-half". This is the lowest value that
+#--- gives acceptable results for test #6 in test.pl. See the pod
+#--- for more information.
+
+$Math::Round::half = 0.50000000000008;
+
+sub round {
+ my $x;
+ my @res = map {
+ if ($_ >= 0) { POSIX::floor($_ + $Math::Round::half); }
+ else { POSIX::ceil($_ - $Math::Round::half); }
+ } @_;
+
+ return (wantarray) ? @res : $res[0];
+}
+
+sub round_even {
+ my @res = map {
+ my ($sign, $in, $fr) = _sepnum($_);
+ if ($fr == 0.5) {
+ $sign * (($in % 2 == 0) ? $in : $in + 1);
+ } else {
+ $sign * POSIX::floor(abs($_) + $Math::Round::half);
+ }
+ } @_;
+ return (wantarray) ? @res : $res[0];
+}
+
+sub round_odd {
+ my @res = map {
+ my ($sign, $in, $fr) = _sepnum($_);
+ if ($fr == 0.5) {
+ $sign * (($in % 2 == 1) ? $in : $in + 1);
+ } else {
+ $sign * POSIX::floor(abs($_) + $Math::Round::half);
+ }
+ } @_;
+ return (wantarray) ? @res : $res[0];
+}
+
+sub round_rand {
+ my @res = map {
+ my ($sign, $in, $fr) = _sepnum($_);
+ if ($fr == 0.5) {
+ $sign * ((rand(4096) < 2048) ? $in : $in + 1);
+ } else {
+ $sign * POSIX::floor(abs($_) + $Math::Round::half);
+ }
+ } @_;
+ return (wantarray) ? @res : $res[0];
+}
+
+#--- Separate a number into sign, integer, and fractional parts.
+#--- Return as a list.
+sub _sepnum {
+ my $x = shift;
+ my $sign = ($x >= 0) ? 1 : -1;
+ $x = abs($x);
+ my $i = int($x);
+ return ($sign, $i, $x - $i);
+}
+
+#------ "Nearest" routines (round to a multiple of any number)
+
+sub nearest {
+ my $targ = abs(shift);
+ my @res = map {
+ if ($_ >= 0) { $targ * int(($_ + $Math::Round::half * $targ) / $targ); }
+ else { $targ * POSIX::ceil(($_ - $Math::Round::half * $targ) / $targ); }
+ } @_;
+
+ return (wantarray) ? @res : $res[0];
+}
+
+# In the next two functions, the code for positive and negative numbers
+# turns out to be the same. For negative numbers, the technique is not
+# exactly obvious; instead of floor(x+0.5), we are in effect taking
+# ceiling(x-0.5).
+
+sub nearest_ceil {
+ my $targ = abs(shift);
+ my @res = map { $targ * POSIX::floor(($_ + $Math::Round::half * $targ) / $targ) } @_;
+
+ return wantarray ? @res : $res[0];
+}
+
+sub nearest_floor {
+ my $targ = abs(shift);
+ my @res = map { $targ * POSIX::ceil(($_ - $Math::Round::half * $targ) / $targ) } @_;
+
+ return wantarray ? @res : $res[0];
+}
+
+sub nearest_rand {
+ my $targ = abs(shift);
+
+ my @res = map {
+ my ($sign, $in, $fr) = _sepnear($_, $targ);
+ if ($fr == 0.5 * $targ) {
+ $sign * $targ * ((rand(4096) < 2048) ? $in : $in + 1);
+ } else {
+ $sign * $targ * int((abs($_) + $Math::Round::half * $targ) / $targ);
+ }
+ } @_;
+ return (wantarray) ? @res : $res[0];
+}
+
+#--- Next lower multiple
+sub nlowmult {
+ my $targ = abs(shift);
+ my @res = map { $targ * POSIX::floor($_ / $targ) } @_;
+
+ return wantarray ? @res : $res[0];
+}
+
+#--- Next higher multiple
+sub nhimult {
+ my $targ = abs(shift);
+ my @res = map { $targ * POSIX::ceil($_ / $targ) } @_;
+
+ return wantarray ? @res : $res[0];
+}
+
+#--- Separate a number into sign, "integer", and "fractional" parts
+#--- for the 'nearest' calculation. Return as a list.
+sub _sepnear {
+ my ($x, $targ) = @_;
+ my $sign = ($x >= 0) ? 1 : -1;
+ $x = abs($x);
+ my $i = int($x / $targ);
+ return ($sign, $i, $x - $i*$targ);
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Math::Round - Perl extension for rounding numbers
+
+=head1 SYNOPSIS
+
+ use Math::Round qw(...those desired... or :all);
+
+ $rounded = round($scalar);
+ @rounded = round(LIST...);
+ $rounded = nearest($target, $scalar);
+ @rounded = nearest($target, LIST...);
+
+ # and other functions as described below
+
+=head1 DESCRIPTION
+
+B<Math::Round> supplies functions that will round numbers in different
+ways. The functions B<round> and B<nearest> are exported by
+default; others are available as described below. "use ... qw(:all)"
+exports all functions.
+
+=head1 FUNCTIONS
+
+=over 2
+
+=item B<round> LIST
+
+Rounds the number(s) to the nearest integer. In scalar context,
+returns a single value; in list context, returns a list of values.
+Numbers that are halfway between two integers are rounded
+"to infinity"; i.e., positive values are rounded up (e.g., 2.5
+becomes 3) and negative values down (e.g., -2.5 becomes -3).
+
+=item B<round_even> LIST
+
+Rounds the number(s) to the nearest integer. In scalar context,
+returns a single value; in list context, returns a list of values.
+Numbers that are halfway between two integers are rounded to the
+nearest even number; e.g., 2.5 becomes 2, 3.5 becomes 4, and -2.5
+becomes -2.
+
+=item B<round_odd> LIST
+
+Rounds the number(s) to the nearest integer. In scalar context,
+returns a single value; in list context, returns a list of values.
+Numbers that are halfway between two integers are rounded to the
+nearest odd number; e.g., 3.5 becomes 3, 4.5 becomes 5, and -3.5
+becomes -3.
+
+=item B<round_rand> LIST
+
+Rounds the number(s) to the nearest integer. In scalar context,
+returns a single value; in list context, returns a list of values.
+Numbers that are halfway between two integers are rounded up or
+down in a random fashion. For example, in a large number of trials,
+2.5 will become 2 half the time and 3 half the time.
+
+=item B<nearest> TARGET, LIST
+
+Rounds the number(s) to the nearest multiple of the target value.
+TARGET must be positive.
+In scalar context, returns a single value; in list context, returns
+a list of values. Numbers that are halfway between two multiples
+of the target will be rounded to infinity. For example:
+
+ nearest(10, 44) yields 40
+ nearest(10, 46) 50
+ nearest(10, 45) 50
+ nearest(25, 328) 325
+ nearest(.1, 4.567) 4.6
+ nearest(10, -45) -50
+
+=item B<nearest_ceil> TARGET, LIST
+
+Rounds the number(s) to the nearest multiple of the target value.
+TARGET must be positive.
+In scalar context, returns a single value; in list context, returns
+a list of values. Numbers that are halfway between two multiples
+of the target will be rounded to the ceiling, i.e. the next
+algebraically higher multiple. For example:
+
+ nearest_ceil(10, 44) yields 40
+ nearest_ceil(10, 45) 50
+ nearest_ceil(10, -45) -40
+
+=item B<nearest_floor> TARGET, LIST
+
+Rounds the number(s) to the nearest multiple of the target value.
+TARGET must be positive.
+In scalar context, returns a single value; in list context, returns
+a list of values. Numbers that are halfway between two multiples
+of the target will be rounded to the floor, i.e. the next
+algebraically lower multiple. For example:
+
+ nearest_floor(10, 44) yields 40
+ nearest_floor(10, 45) 40
+ nearest_floor(10, -45) -50
+
+=item B<nearest_rand> TARGET, LIST
+
+Rounds the number(s) to the nearest multiple of the target value.
+TARGET must be positive.
+In scalar context, returns a single value; in list context, returns
+a list of values. Numbers that are halfway between two multiples
+of the target will be rounded up or down in a random fashion.
+For example, in a large number of trials, C<nearest(10, 45)> will
+yield 40 half the time and 50 half the time.
+
+=item B<nlowmult> TARGET, LIST
+
+Returns the next lower multiple of the number(s) in LIST.
+TARGET must be positive.
+In scalar context, returns a single value; in list context, returns
+a list of values. Numbers that are between two multiples of the
+target will be adjusted to the nearest multiples of LIST that are
+algebraically lower. For example:
+
+ nlowmult(10, 44) yields 40
+ nlowmult(10, 46) 40
+ nlowmult(25, 328) 325
+ nlowmult(.1, 4.567) 4.5
+ nlowmult(10, -41) -50
+
+=item B<nhimult> TARGET, LIST
+
+Returns the next higher multiple of the number(s) in LIST.
+TARGET must be positive.
+In scalar context, returns a single value; in list context, returns
+a list of values. Numbers that are between two multiples of the
+target will be adjusted to the nearest multiples of LIST that are
+algebraically higher. For example:
+
+ nhimult(10, 44) yields 50
+ nhimult(10, 46) 50
+ nhimult(25, 328) 350
+ nhimult(.1, 4.512) 4.6
+ nhimult(10, -49) -40
+
+=back
+
+=head1 VARIABLE
+
+The variable B<$Math::Round::half> is used by most routines in this
+module. Its value is very slightly larger than 0.5, for reasons
+explained below. If you find that your application does not deliver
+the expected results, you may reset this variable at will.
+
+=head1 STANDARD FLOATING-POINT DISCLAIMER
+
+Floating-point numbers are, of course, a rational subset of the real
+numbers, so calculations with them are not always exact.
+Numbers that are supposed to be halfway between
+two others may surprise you; for instance, 0.85 may not be exactly
+halfway between 0.8 and 0.9, and (0.75 - 0.7) may not be the same as
+(0.85 - 0.8).
+
+In order to give more predictable results,
+these routines use a value for
+one-half that is slightly larger than 0.5. Nevertheless,
+if the numbers to be rounded are stored as floating-point, they will
+be subject, as usual, to the mercies of your hardware, your C
+compiler, etc.
+
+=head1 AUTHOR
+
+Math::Round was written by Geoffrey Rommel E<lt>GROMMEL at cpan.orgE<gt>
+in October 2000.
+
+=cut
Propchange: branches/upstream/libmath-round-perl/current/Round.pm
------------------------------------------------------------------------------
svn:executable = *
Propchange: branches/upstream/libmath-round-perl/current/test.pl
------------------------------------------------------------------------------
svn:executable = *
More information about the Pkg-perl-cvs-commits
mailing list