use strict;

my @old = (237,153,258,231,154,159,141);
my %unique = map {$_ =>1} @old; #just in case the old rankins are not 
+unique
my @ordered = sort keys %unique;
my %map = ();
for my $i (0..$#ordered){
    $map{$ordered[$i]} = $i+1;
}

foreach my $i (@old){
    print $i, "=>",$map{$i}/scalar(@ordered),"\n";
}
__END__
237=>0.857142857142857
153=>0.285714285714286
258=>1
231=>0.714285714285714
154=>0.428571428571429
159=>0.571428571428571
141=>0.142857142857143
[download]

What data structure do you have the data in? That will determine the details of how to do this.

Lets suppose you can get a column as a list (not necessarily an array). You can grep to remove db NULL's, which are undef in perl, and use references to the data to do something like this.

# $data is a hashref, a standin for the data struct you have
my @ranks = \(grep {defined} values %$data);
my $idx = 0;
$$_ = ++$idx for sort {$$a <=> $$b} @ranks;    # step 1 & 2
$$_ /= $idx for @ranks;                        # step 3
[download]

If you wanted them back into their original order, you have another step to make.

#! perl -slw
use strict;

my @data =  map{ chomp; [ split '\s*\|\s*', $_ ] } <DATA>;

my @counts;
for my $field ( 1 .. 3 ) {
    my $rank = 0;
    @data = map { 
        $_->[ $field ] and $_->[ $field ] = ++$rank; 
        $_; 
    } sort { 
        ( $a->[ $field ]||0 ) <=> ( $b->[ $field ]||0 ) 
    } @data;
    $counts[ $field ] = $rank;
}

for my $data ( @data ) {
    map {
        $data->[ $_ ] and $data->[ $_ ] 
            = sprintf '%5.3f', $data->[ $_ ] /= $counts[ $_ ];
    } 1 .. 3;
}
print join "\t", @$_ for @data;

__DATA__
ENSG00000179050 |             |               |           4 
ENSG00000124183 |         237 |               |           2 
ENSG00000179033 |             |               |           7 
ENSG00000124181 |             |           13  |           1 
ENSG00000174306 |             |               |           5 
ENSG00000132793 |             |               |           8 
ENSG00000183798 |             |               |           6 
ENSG00000124177 |             |               |           3 
ENSG00000087530 |         153 |               |             
ENSG00000185513 |         258 |               |             
ENSG00000101052 |         231 |               |             
ENSG00000124249 |         154 |             7 |             
ENSG00000101098 |         159 |               |             
ENSG00000166913 |         141 |               |             
__OUTPUT__
P:\test>383173
ENSG00000166913 0.143
ENSG00000087530 0.286
ENSG00000101098 0.571
ENSG00000101052 0.714
ENSG00000185513 1.000
ENSG00000124249 0.429   0.500
ENSG00000124181         1.000   0.125
ENSG00000124183 0.857           0.250
ENSG00000124177                 0.375
ENSG00000179050                 0.500
ENSG00000174306                 0.625
ENSG00000183798                 0.750
ENSG00000179033                 0.875
ENSG00000132793                 1.000
[download]

I'm going to feed the output to a recursive formula, used in order statistics. (Therefore the rankings: the rank of the values is important for me)

Update:Upon further reading about your module, it does seem quite interessting. Will give it a try.

I'd do it something like this:

  my @genes;  # I assume these come from somewhere

  for my $style (qw/ g2d pocus dgp /) {
    my($in, $out) = ($style . "_ranking", $style . "_rankratio");

    # step 1: locate and sort the relevant genes for this ranking styl
+e
    my @set = sort { $a->{$in} <=> $b->{$in} } grep $_->{$in}, @genes;

    # step 2: get a count
    my $total = @set;

    # step 3: update the located genes with a rankratio
    for my $index (0 .. $#set) {
      $set[$index]{$out} = ($index + 1) / $total;
    }
  }
[download]

Notes: I select the genes that have a particular ranking specified by checking $_->{$in} in a boolean context, so that it'll be false for zero or undef without warnings; I never store the intermediate re-based ranking as it is implicit in the order of @set; I only loop over the selected genes to update them, so I won't try to update an undef value, nor (since there would be zero loop iterations) will this try to divide by zero.

This code is untested.

Hugo