Moving on to fractions, when I heard that raku was going to deal with fractions in a clever way, I decided to experiment and write my own module to do fractions. Instead of adulting tonight, I decided to spend a little time fiddling with code.

Here's my test script:

#!/usr/bin/perl

use strict;
use warnings;

#  OK, try the division of the large numbers using my
#  Number::MyFraction module. No idea what result I'll get.

use lib '../Number-MyFractions/lib';

use Number::MyFraction;

{
    my $long_tenth =
      Number::MyFraction->new( 3602879701896397, 36028797018963968 );

    my $short_tenth = Number::MyFraction->new( 1, 10 );

    my $difference = $long_tenth - $short_tenth;

    print "Compare long tenth: "
      . ( $long_tenth->decimal_val == .1 ? 'TRUE' : 'FALSE' ) . "\n";
    print "Compare short tenth: "
      . ( $short_tenth->decimal_val == .1 ? 'TRUE' : 'FALSE' ) . "\n";

    print "The different is " . $difference->decimal_val . ".\n";
}
[download]

$ perl 11137153.pl
Compare long tenth: TRUE
Compare short tenth: TRUE
The different is 5.55111512312578e-18.
$
[download]

I think it just depends on which tool you use to get the job done.

First up, I apologise for tainting this thread with that previous post of mine.
I need to keep in mind that raku was not written for me, but written for a group of people who find that raku suits them, and who are quite happy with what raku provides - and that I have no business complaining about anything that raku does.

I think it just depends on which tool you use to get the job done.

I see just 2 ways to compare rationals and doubles:
1) convert the rational to a double and compare the two doubles;
or
2) convert the double to a rational and compare the two rationals.

The former is probably the easier, and that's the approach that raku takes.
But, in converting a rational to a double, it is often the case that precision is lost, and the double thus obtained is merely an approximation of the rational value from which it was derived.
OTOH, every finite double can be represented exactly as a rational - and it therefore makes sense to me that they should be compared via the latter option (like python3 does), as we are then always comparing exact values.
There's a caveat here in that the numerators/denominators needed to express some doubles can be rather large, and this could be viewed as a dis-incentive to using this second option.

Perl doesn't have a rational scalar, and C doesn't have a rational data type, so neither of those languages have needed to think about how rationals and floats should be compared.
(Of course, perl has a core Math::BigRat module in which the overloading of comparision operators needed to be considered.)

Cheers,
Rob

hi rob, from the docs we have:

> my $x = 1/10;   #0.1
> $x.^name;       #Rat

> my  $y = 3602879701896397/36028797018963968;   #0.100000000000000006
> $y.^name;       #Rat

> $x == $y         #False   (no coercion necessary)
> $x == 0.1        #True     (no coercion necessary)
> $y == 0.1        #False   (no coercion necessary)
so comparing without coercion works as you expect

> 0.1e0.^name;  #Num
> $x == 0.1e0    #True    (coerces $x to Num, then compares)
> $y == 0.1e0    #True    (coerces $y to Num, then compares)

coercion from Rat to Num can result in loss of precision
> say $y.nude   #(3602879701896397 36028797018963968)
> say $y.Num    #0.1     
coercing this particular Rat to a Num collapses it to 0.1
IIRC the limit of Rat precision is e-14 ish (it gets lumpy), 
so in the general case it is fair to round away your ...00006 to 0
thus the Num 0.1 maps to both of these Rat options
[download]

your python example does much the same...

Coerces both arguments to Numeric (if necessary)...

That's an unfortunate choice, IMO.

coercion from Rat to Num can result in loss of precision

And that's the reason that I don't like that choice. If instead, the Num was coerced to Rat, then there would be no loss of precision.

your python example does much the same...

If that were so, then I think the following python3 one-liner would print "True":

$ python3 -c 'from fractions import Fraction; print (Fraction(1,10) ==
+ 0.1);'
False
[download]

Even though the Fraction (Rat) 1/10 coerces to the float (Num) 0.1e0, python3 still recognizes that the 2 values are not equivalent.

My only other experience with comparisons between rational types and floating point types is in the mpfr library where, like python3, the comparison is made between the "Rat" (mpq_t) and the exact rational value of the "Num" (mpfr_t) using the mpfr_cmp_q function.
The gmp library has both a "Num" (mpf_t) and "Rat" (mpq_t) type, but doesn't provide any public functions for directly comparing the 2 types. It's therefore up to the user to come up with the comparison routines.

Anyway, if raku users are happy with the approach taken then there's not much point in complaining about it.
(And I haven't yet encountered any raku users that are unhappy with that current approach.)

Cheers,
Rob