The problem with comparing two floats with a tolerance is that the comparison is not transitive. That is, even though a==b and b==c, it may be that a!=c.

This might become important in such situations as passing a sorting or searching function. I am more familiar with this situation in C++ and Java. In Java, there is such a thing as the "equals contract", which states that the equals function must be reflexive (a==a), symmetric (a==b, b==a) and transitive (a==b, b==c, a==c). This is important for building HashSet and HashMap objects, and there are similar rules in C++ for the STL containers and algorithms.

Being something of a perl noob, I don't know if there are similar constraints in Perl libraries, but it's a good rule to bear in mind anyway.

If a comparison function is not transitive, you are just pushing the surprising behaviour into a darker corner.

Computers generally don't handle floating point numbers the way we expect them to. For instance, while you might think a number is 4.3, the computer might store it as 4.2999999999999. For most applications, this is probably fine, but you have to round the results when you display them. To compare two floating point numbers, use the sprintf function, figure out how many significant digits you need and compare with a string equal comparison operator (eq).

sub floats_eq {
    my ($num1, $num2, $sig) = @_;
    $_ = sprintf "%.${sig}g" foreach $num1, $num2;
    return $num1 eq $num2;
}
[download]

You should also note that while floating point numbers won't be exact, two numbers arrived at through the same calculation (4 / 7, for instance) will be the same. This means that under some conditions, rounding isn't necessary - and under others, a simple fraction class is probably going to be better than trying to approximate comparisons.

Your reasoning is sound. I have only a small remark. If you want to print the two numbers to show their differences, increase the number of decimals.

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

my ( $number, $premium, $expected );

$number   = 1.80;
$premium  = $number * ( 1 + 10/100 );  # 1.8 + 10% of 1.8
$expected = 1.98;  # As we know 1.8 + 10% of 1.8 is 1.98

printf "Number 1 : %20.19f\n", $premium  ;
printf "Number 2 : %20.19f\n", $expected ;
print "Not" if ( $expected != $premium );
print "Equal !! ";
__END__
Number 1 : 1.9800000000000002043
Number 2 : 1.9799999999999999822
NotEqual !!
[download]

If you create a text file x.txt with following data

227.20
1176.00
262.00
481.60
492.00
489.60
808.50
934.50
150.00
806.00
563.70
295.60
552.90
327.25
0.00
0.00
0.00
[download]

7566.85
[download]

open (X,"< x.txt");
while ($n = <X>) {
    $n =~ s/\n|\r//g;   # same with or without
    $t += $n;
}
close X;
$st = `cat x2.txt`;
$st =~ s/\n|\r//g;  # same with or without
print "t  = $t\n";
print "st = $st\n";

if (equal($t,$st,5)) {
    print "Equal\n";
} else {
    print "Different\n";
}

sub equal {
    my ($A,$B,$dp) = @_;

    return sprintf("%.${dp}g",$A) eq sprintf("%.${dp}g",$B);
}
[download]

t  = 7566.85
st = 7566.85
Different
[download]

sub equal {
    my ($A,$B,$dp) = @_;

    if ($A == $B) {
        return 1;
    } elsif ($A eq $B) {
        return 1;
    }
    return sprintf("%.${dp}g",$A) eq sprintf("%.${dp}g",$B);
}
[download]

t  = 7566.85
st = 7566.85
Equal
[download]