How to force long double in Perl

I lose precision when doing arithmetic or trying to print (debug) numbers this big: 1234567890.123456789

I think my problems are with $d (result of arithmetic) and the formatted print of $e. How can I force long doubles? My Perl version (5.8.4 on SUN) says it's possible. sprintf has a size option for long doubles (q or L or ll), but I haven't figured out how to use it, and don't know if it would work with printf.

Edit: I added BigFloat, which works! But I'd still like to force long doubles.

Try to add 1234567890 + 0.123456789 and subtract 1234567890 - 0.123456789.

use Config;
use Math::BigFloat;
$a = 1234567890;
$b = 123456789;
$c = $b/1e9;                   # 0.123456789
$d = $a + $c;                  # not enough precision (32-bit or double?)
$e = sprintf("%d.%.9d",$a,$b); # combine as strings
$f = 1234567890.123456789;     # for reference (not enough precision)

# Use BigFloat to bypass lack of longdbl
$aBig = Math::BigFloat->new("$a");
$dSum = $aBig->fadd("$c");         # $dSum = $a + $c
$aBig = Math::BigFloat->new("$a"); # <-- Need a new one for every operation?
$dDif = $aBig->fsub(abs("$c"));    # $dDif = $a - $c

print "a $a\n";             # 1234567890  
print "c $c\n";             # 0.123456789
print "d=a+c $d\n";         # 1234567890.12346  <-- **Problem**
print "dSum=a+c $dSum\n";   # 1234567890.123456789  <-- Solution
print "dDif=a-c $dDif\n";   # 1234567890.876543211  <-- Solution
print "e $e\n";             # 1234567890.123456789
print "f $f\n";             # 1234567890.12346  <-- double, 52-bit, not longdbl? 
printf ("printf    e 20.9f %20.9f\n",$e);    # 1234567890.123456717 <-- **Problem**
printf ("printf dSum 20.9f %20.9f\n",$dSum); # 1234567890.123456717 <-- **Problem**
printf ("printf dSum 20s %20s\n",$dSum);     # 1234567890.123456789 
printf ("printf dDif 20.9f %20.9f\n",$dDif); # 1234567890.876543283 <-- **Problem**
printf ("printf dDif 20s %20s\n",$dDif);     # 1234567890.876543211 

print "uselongdouble $Config{uselongdouble}\n"; # empty. No long doubles by default
print "d_longdbl $Config{d_longdbl}\n";         # "define". Supports long doubles
print "size double longdbl $Config{doublesize} $Config{longdblsize}\n"; # Ans 8 16

I also used this code to try to understand the types, but it didn't help much. Has anyone used it to explain problems like this?

use Devel::Peek 'Dump';

Dump ($dSum); # Wow, it's complicated
Dump ($f);

Solution

bignum will overload all operators in the current scope to use arbitrary precision integers and floating point operations.

use bignum;

my $f = 123456789.123456789;
print "$f\n";         # 123456789.123456789
print $f + $f, "\n";  # 246913578.246913578

Behind the scenes, bignum turns all numeric constants into Math::BigInt and Math::BigNum objects as appropriate.

It's important to note that bignum is lexically scoped and does not effect the whole program. For example...

{
    use bignum;
    $f = 123456789.123456789;  # $f is a Math::BigNum object
}

$g = 123456789.123456789;      # $g is a regular NV

print "$f\n";     # 123456789.123456789
print "$g\n";     # 123456789.123457

# This will use Math::BigNum's addition method, but $g has already lost precision.
print $f + $g, "\n";  # 246913578.246913789

You can get a bit better performance out of this by using the Math::BigInt::GMP plugin to use the GNU Multiple Precision Arithmetic Library for some operations. You have to install that module first using the normal CPAN install process (you don't need GMP). Then tell bignum to use GMP.

use bignum lib => "GMP";