Re^4: sort direction

[BrowserUk]

Well, using sort{$b-$a} @numbers rather than sort{$b<=>$a} @numbers seems to run quite a bit more quickly and produce the desired result:

perl> cmpthese -1, {
    '<=>' => q[@s1=sort{$b<=>$a} 1..10000], 
    '-'   => q[@s2=sort{$b - $a} 1..10000] 
};;
       Rate  <=>    -
 <=> 33.8/s   -- -82%
-     183/s 441%   --

There are probably good reasons why this shoudln't be done outside of golf though.

[Perl Mouse]

That result highly surprised me, because sort is optimized for the {$a <=> $b}, {$b <=> $a}, {$a cmp $b} and {$b cmp $a} blocks (in the sense it recognises those blocks and does the compare internally instead of calling the block).

But then I realized that the current sort implementation is also implemented to take advantage of long runs of increasing/decreasing values - and in particulary sorted arrays.

So I decided to run the benchmark again, this time with shuffled values:

#!/usr/bin/perl

use strict;
use warnings;

use Benchmark 'cmpthese';
use List::Util 'shuffle';

our @data = shuffle 1 .. 10000;

cmpthese -1, {
    '<=>'  => q[@s1=sort{$b<=>$a} @data],
    ' - '  => q[@s2=sort{$b - $a} @data],
};

__END__
      Rate   -   <=>
 -  36.5/s   -- -30%
<=> 52.3/s  43%   --

That's what I'd expect.

[BrowserUk]

Sigh. Fooled again :)

[BrowserUk]

Then again, if you eliminate the optimisation advantage;

#!/usr/bin/perl

use strict;
use warnings;

use Benchmark 'cmpthese';
use List::Util 'shuffle';

our @data = shuffle 1 .. 10000;

cmpthese -1, {
    '<=>'  => q[@s1=sort sub{ $b<=>$a }, @data],
    ' - '  => q[@s2=sort sub{ $b - $a }, @data],
};

__END__
P:\test>junk
      Rate <=>  -
<=> 36.9/s  -- -2%
 -  37.4/s  2%  --

P:\test>junk
      Rate  -  <=>
 -  36.3/s  -- -3%
<=> 37.4/s  3%  --

P:\test>junk
      Rate  -  <=>
 -  35.8/s  -- -0%
<=> 35.8/s  0%  --

P:\test>junk
      Rate <=>  -
<=> 36.8/s  -- -0%
 -  36.9/s  0%  --

... it makes no difference whether the block returns (-1,0,1) or (-n,0,n), which is more relavent to the original discussion.

However, in C or asm, it might avoid an unnecessary booleanisation of a subtraction?