Abigail

Thank-you: that was exactly the problem. Merely replacing Math::Big::factorial with Math::BigFloat::bfac fixed it. The code's below for posterity's sake:

use strict;
use Math::BigFloat;

my $G = 11057;    #$ARGV[0];
my $C = $ARGV[0];
my $n = $ARGV[1];
my $k = $ARGV[2];

sub choose {

    my $ret_val    = Math::BigFloat->new();
    my $n        = Math::BigFloat->new($_[0]);
    my $r        = Math::BigFloat->new($_[1]);
    my $n_r        = Math::BigFloat->new($_[0] - $_[1]);

    $n->bfac();
    $r->bfac();
    $n_r->bfac();

    $ret_val = $n / ($n_r * $r);

    return $ret_val;

    }

my $p = Math::BigFloat->new('1');
my $denom = Math::BigFloat->new(choose($G, $n));

for (my $i = 0; $i < $k; $i++) {

    my $val1 = $G - $C;
    my $val2 = $n - $i;

    my $delta = Math::BigFloat->new();
    $delta = choose($C, $i) * choose($val1, $val2) / $denom;
    $p -= $delta;
    }

print "Probability estimate: $p\n";
[download]

Two points. I found that if I used Math::BigFloat in the choose function, I got round off errors; errors I didn't get when using Math::BigInt.

Second, I got a much better performance for the choose function if I didn't calculate 3 factorials, but just one, and did some multiplication myself. The further the second argument is away from half of the first argument, the bigger the advantage. Here's a benchmark:

#!/usr/bin/perl  
     
use strict;
use warnings;
                                   
use Math::BigFloat;
use Benchmark qw /timethese cmpthese/;

#
# choose (n, k) == n! / ((n - k)! * k!) == n! / (n - k)! / k!
#               == n * (n - 1) * ... * (n - k + 1) / k!
    
    
sub choose_fac {
    my ($n, $k) = @_;

    Math::BigInt -> new ($n) -> bfac            /
          Math::BigInt -> new ($n - $k) -> bfac /
          Math::BigInt -> new ($k)      -> bfac
}

sub choose_mul {
    my ($n, $k) = @_;
  
    $k = $n - $k if $k > $n - $k;  # Make the loop smaller;
                                   # we can do this because
                                   # choose (n, k) == choose (n, n - k
+).
 
    my $p       = Math::BigInt -> new (1);
    my $start   = $n - $k + 1;
 
    for (my $i = $start; $i <= $n; $i ++) {
        $p *= $i;
    }

    $p / Math::BigInt -> new ($k) -> bfac;
}                                  


our (@r1, @r2);
our  @pairs = map {[/(\d+)\s+(\d+)/]} <DATA>;

cmpthese -10 => {
    fac      => '@r1 = map {choose_fac @$_} @pairs',
    mul      => '@r2 = map {choose_mul @$_} @pairs',
};
    

die "Unequal" unless "@r1" eq "@r2";
          
__DATA__
1000    0
1000  100
1000  500
1000 1000


    s/iter  fac  mul
fac   2.08   -- -89%
mul  0.226 824%   --
[download]

Abigail