#!/usr/bin/perl
use strict;
use warnings;

my $i = 1.255;
my $j = $i * 100 + 0.5;

print "$j\n";
printf "%.16e\n", $j;
[download]

outputs

126
1.2599999999999999e+002
[download]

If your result is sufficiently sensitive that this is problematic, you can use Math::BigFloat, but this is likely a lot more complexity than a real world application requires.

Perl rounds them upon printing, it looks like an even number, but it is not.

$ perl -wE 'say +(1.255 * 100 + 0.5) * 10000000'
1260000000
$ perl -wE 'printf "%.20f\n", (1.255 * 100 + 0.5) * 10000000'
1259999999.99999976158142089844
[download]

255/1000 is a periodic number in binary just like 1/3 is a periodic number in decimal. It would take infinite storage to store it as a floating point number, so it is stored approximately.

$ perl -e'printf "%.20e\n", 1.255'
1.25499999999999989342e+00

$ perl -e'printf "%.20e\n", (1.255 * 100 + 0.5) * 10000000'
1.25999999999999976158e+09
[download]

Is there a way to make perl behave as a humble user of arithmetics would have expected

No. If you're using floats, there's no way to make both of these true since the input is the same:

int(1259999999.999999)              = 1259999999
int((1.255 * 100 + 0.5) * 10000000) = 1256000000
[download]

Said humble user will be disappointed in one of the two cases. But maybe you're ok with the user being disappointed in the former case. Just apply a bit of rounding at the desired tolerance.

( $j = sprintf("%.6f", $j) ) =~ s/\..*//s;
[download]

print int ( $j + 0.5);
[download]

Thank you, fellow monks. While two of the above answers pointed out that int is exactly doing what its supposed to do, Rata followed the rather pragmatic approach to show how to actually use the int-function to get the expected result. Let me please try to hold awaken the interest in the practial approach, while peeking into the computer scientist material later.

In the following view on the problem, I try to round the number 1.255, and try to get the result 1.26. How would you perform this with the typical on-board means, to which undenyingly int() belongs to?

#!/usr/bin/perl
my $i = 1.255;
print int($i*100+.5)/100;
print "\n";
[download]

Please register, that the same code will do as expected when using "1.355" as value for $i.

If you are going to be formatting a number for output, I would suggest you use the methods designed specifically to handle that - printf and sprintf. If you are rounding/truncating a value in the context of numerical manipulation, then the approach you take very much depends on your specific needs. There is a very rich field of academic study revolving around performing computations with discrete approximations.

#!/usr/bin/perl
use strict;
use warnings;

my $i = 1.255;
my $j = $i * 100 + 0.5;
$j *= 10000000;

printf "%.0f\n", $j;
[download]

outputs

1260000000

Hello there, its me again, the Anonymous Monk! :-)

Starting a new day, I felt refreshed to wrestle with the rounding problem again. To get to the beef, here is my proposal to round numbers using the int-function:

#!/usr/bin/perl

my $float = $ARGV[0] ? $ARGV[0] : 1.255;
my $decimals = $ARGV[1] ? $ARGV[1] : 2;

print &round( $float , $decimals ) . "\n";


sub round {
  my $float = shift;
  my $decimals = shift;
  my $int_leftShiftFloat = int( $float * 10**($decimals + 1) );
  my $int_Round = int( ( $int_leftShiftFloat + 5 ) / 10 );
  my $float_rightShiftInt = $int_Round / 10**$decimals;
  my $float_Result = $float_rightShiftInt;
  return $float_Result
}


sub round_ {
  my $float = shift;
  my $dec = shift;
  return int( ( int( $float * 10**($dec + 1) ) + 5 ) / 10 ) / 10**$dec
}
[download]

I've provided to functionally identical versions of the sub, so you may pick up which one is easier for you to read.

In the long version of the sub, I've tried to use speaking variable names and left out any comments instead.

To make a general comment on this solution, I've followed the suggestions provided yesterday by my fellow monks, and made the computation using integers to avoid the floating point hassle. What do you think about it?