# $rounded = round($value, $places);
sub round {
  my ($N,$P) = @_;
  my $pm = $N > 0 ? 1 : -1;
  return int($N * 10**$P + .5 * $pm) / 10**$P;
}
[download]

The POSIX module contains functions called ceil and floor which return the first integer greater or less than a given number.

#!/usr/bin/perl -w
use strict;

use POSIX qw(ceil floor);

my @numbers = qw(1 1.2 1.5 1.7 -1.2 -1.5 -1.7);

foreach (@numbers) {
  printf("x: %.1f: ceil(x): %d floor(x) %d\n", 
         $_, ceil($_), floor($_));
}
[download]

"Perl makes the fun jobs fun
and the boring jobs bearable" - me

AgentM Systems nor Nasca Enterprises nor Bone::Easy nor Macperl is responsible for the comments made by AgentM. Remember, you can build any logical system with NOR.

use integer is interesting, but I wouldn't call that rounding (similar with ceil and floor). Certainly it depends on what your numbers represent, but if you have a set of values that should have a known sum, proper rounding works much better than truncation. On the other hand, if your numbers represent, say, the number of people that can fit in a vehicle, you definitely want integers, and definitely want truncation of the values, lest you risk truncation of the people when the erroneous result is tested ;-).

It's also worth noting that it affects the definition of the binary % operator, in that you get the native C compiler version which may not behave as expected for negative values.

--
I'd like to be able to assign to an luser

--
I'd like to be able to assign to an luser

The rounding-part of my question was just asked out of sheer curiosity.

The part about the alternative division op came to my mind since I had been programming a little bit of ol' fashioned PASCAL before
and PASCAL does contain an operator (or function) like that.

$num++   if  $num =~ s#\.(\d*)##  &&  "5" le $1;
[download]

Though this "rounds" things like 1.23e14 to 1e14 !

Jeroen
"We are not alone"(FZ)

use POSIX;
$round = floor($num + 0.5);
#unless you need to round .5 to even
[download]

sub round {
    my $temp=$_[0];
    my $rounded=0;
    while ($temp>.5) {
          $temp--;
          $rounded++;
    }
    return $rounded;
}

print &round(23.9);
[download]

sub trunc {
  my $r = shift;
  return 0 if ! $r;
  my $s = $r + $r/abs($r);
  return $r % $s;
}
sub grr {
  my ($q, $d) = @_;
  return int( $q/$d);
}
[download]

And honestly, any language that implements a round function invisibly inplements a numerical truncate like "int()" if it doesn't do it explicitly. For instance, to pick a random language say "Perl" =), the '%' modulus forces both of it's arguments to int's before using them.

--
$you = new YOU;
honk() if $you->love(perl)

I don't know if there is a module for accountancy rounding; I ended up using

$toround =~ /\.(\d)/;
if ($1 >= 5) { $toround+=.5 }
$toround = int $toround;
[download]

Update Duh, and it uses int(). Excuse my idiocy.
Dave