This has come up before; but I can tell you right off the bat your code is more complicated than it needs to be. In the following:

  if ($outcome > 97) { $rv .= "99"; }
  elsif ( ($outcome > 93) && ($outcome <= 97) )
[download]

    if ( $outcome > 97 ) { $rv .= "99"; }
 elsif ( $outcome > 93 ) { $rv .= "95"; }
 elsif ( $outcome > 85 ) { $rv .= "90"; }
 elsif ( $outcome > 75 ) { $rv .= "80"; }
 elsif ( $outcome > 65 ) { $rv .= "70"; }
 elsif ( $outcome > 55 ) { $rv .= "60"; }
 elsif ( $outcome > 45 ) { $rv .= "50"; }
 elsif ( $outcome > 35 ) { $rv .= "40"; }
 elsif ( $outcome > 25 ) { $rv .= "30"; }
 elsif ( $outcome > 15 ) { $rv .= "20"; }
 elsif ( $outcome >  7 ) { $rv .= "10"; }
 elsif ( $outcome >  3 ) { $rv .= "05"; }
 elsif ( $outcome >  0 ) { $rv .= "00"; }
[download]

A slightly shorter version of the above code.

$rv .= $outcome > 97 ? 99
     : $outcome > 93 ? 95
     : $outcome > 85 ? 90
     : $outcome > 75 ? 80
     : $outcome > 65 ? 70
     : $outcome > 55 ? 60
     : $outcome > 45 ? 50
     : $outcome > 35 ? 40
     : $outcome > 25 ? 30
     : $outcome > 15 ? 20
     : $outcome >  7 ? 10
     : $outcome >  3 ? '05'
     : $outcome >  0 ? '00'
     :                 q{};
[download]

You could bring your limits and calculated rv's into an array of arrays, and then iterate through it to test outcomes. See below:

use strict;
use warnings;

my @outcome_tests = (
    [ 97, 100, '99' ],
    [ 93,  97, '95' ],
    [ 85,  93, '90' ],
    [ 75,  85, '80' ],
    [ 65,  75, '70' ],
    [ 55,  65, '60' ],
    [ 45,  55, '50' ],
    [ 35,  45, '40' ],
    [ 25,  35, '30' ],
    [ 15,  25, '20' ],
    [  7,  15, '10' ],
    [  3,   7, '05' ],
    [  0,   3, '00' ],
);

for( 1 .. 20 ) {                      # Run the test 20 times.
    my $outcome = int( rand( 100 ) + 1 ); # Generate some test data.
    my $rv = '';
    TEST: {   
        foreach my $test ( @outcome_tests ) {
            my( $lower, $upper, $category ) = @{ $test };
            if(
                $outcome > $lower  and
                $outcome <= $upper
            ) {
                $rv .= $category;
                last TEST;
            }
        }
        die "ERROR: $outcome is out of bounds.\n";
    }
    print "$outcome => $rv\n";
}
[download]

One advantage to this solution is that it turns your limits and categories into data, rather than code. You can add or remove limit pairs without altering the code, and without affecting complexity.

A solution that might lack elegance but should be pretty fast is a simple hash look-up. Construct a hash with keys running from 1 .. 100 and values equivalent to the 'probability' for each key. Something like this:

my $outcome = shift;

my %h = map { $_ => 10 * int ( ( $_ + 4 ) /10 ) } 8 .. 93;
@h{1 .. 3}    = (0)  x 3;
@h{4 .. 7}    = (5)  x 5;
@h{94 .. 97}  = (95) x 4;
@h{98 .. 100} = (99) x 3;

print defined $h{$outcome} ? sprintf "%02d\n", $h{$outcome} : 'ERROR';
[download]

Update: Just realised that your numbers don't have to be integers. If so, change the beginning of the above to:

use POSIX;
my $outcome = ceil( shift );
[download]

You can do this much more efficiently, O(1), by using a lookup table.

my @lookup = ( '00', 
    map {
        ( $_->[2] ) x ( $_->[ 1 ] - $_->[ 0 ] )
    }   
    [  0,   3, '00' ], [  3,   7, '05' ], [  7,  15, '10' ],
    [ 15,  25, '20' ], [ 25,  35, '30' ], [ 35,  45, '40' ],
    [ 45,  55, '50' ], [ 55,  65, '60' ], [ 65,  75, '70' ],
    [ 75,  85, '80' ], [ 85,  93, '90' ], [ 93,  97, '95' ],
    [ 97, 100, '99' ]
);

print "@lookup";

$rv .= $lookup[ ((( $prob - 0.5 )*2 )+( $conf * 100 )) ];
[download]

And as is periodically mentioned, the conventional wisdom on using Switch in production is "you shouldn't" (straight from the horse's mouth, Categorized Damian Modules).

Update: And as for suggestions, since you've got a predicate rather than a simple key you could still use a dispatch table, it's just not as direct. I haven't looked at your sample data directly, but often you can find some mathematical function which converts a value to a "bin" number (as a really trivial example, something like int( $value / 10 ) to map a value 0..100 into bins 0..10). You then use that function as the key in your dispatch table instead.

Fletch,
A similar module (Case) by Roy Johnson is not written using source filters or evil goto. It may not suit madbombX's purpose (performance) but for clarity it may be a nice alternative.

Cheers - L~R

my $rv = $lookup{$outcome};
[download]

$dispatch->{bin_search($outcome)}->();
[download]