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