I'm not sure it would be faster, but you can use the nifty grep operator in conjunction with the keys function to achieve similar effects:

sub getIntensity {
    my $target = shift; # => $_[0], idiomatic
    my $tol = .3;
    my @matching_keys = 
        grep { abs($target-$_) <= $tol } keys %massint;
    my $intensity = 0;
    foreach (@matching_keys) {
        $intensity = $massint{$_} > $intensity ? 
            $massint{$_} : $intensity;
    }
    $intensity;
}
[download]

First, you grab the keys within the tolerance range, and then you go through them to nab the greatest value (the ternary operator EXPR ? EXPR1 : EXPR2 returns EXPR1 if EXPR is true, and EXPR2 otherwise). You could, of course, do away with @matching_keys and run the foreach over the grep statement, but that doesn't illustrate the technique as clearly.

HTH

Philosophy can be made out of anything. Or less -- Jerry A. Fodor

It works like so. It determines the max value over the +/- 0.3 window for each mass in the range LOW - 0.3 to HIGH + 0.3, and it also remembers WHICH mass it found that intensity at. This way, when it gets to the next number, it knows where to start looking -- there's no need to look BEFORE the highest value for a higher value, since it would've been registered as the highest value.

my $cache = cacheMaxIntensity(\%massint);

sub cacheMaxIntensity {
  my $mi = shift;
  my ($min, $max);
  
  # determine the maximum and minimum masses
  # in the hash
  while (my ($m) = each %$mi) {
    $min = $m if not defined($min) or $min > $m;
    $max = $m if not defined($max) or $max < $m;
  }

  # the "latest mass" is defined as the mass within a
  # +/- 0.3 range with the highest intensity
  my $latest = $min - 0.3;
  my %cache = ();
  
  # cycle through all the masses, including
  # 3 less than the min and 3 greater than the max
  for (my $m = $min - 0.3; $m <= $max + 0.3; $m += 0.1) {

    # ensure "ABC.D" format (icky non-integers)
    $m = sprintf("%.1f", $m);
    
    # update the value of $latest if it's too
    # far away from the current mass
    $latest = sprintf("%.1f", $m - 0.3)
      if $m - 0.3 > $latest;

    # build the range (latest .. current + 0.3)
    # of other masses to examine
    for my $d (
      map sprintf("%.1f", $_ / 10),
        (10 * $latest) .. (10 * $m + 3)
    ) {

      # set the cached intensity for this mass
      # to the intensity for $d IF:
        # there is an intensity for $d
        # AND
          # there is no cached intensity yet
          # OR
          # the intensity for $d is greater than
          # the cached value

      $cache{$m} = [ $mi->{$d}, $latest = $d ]
        if exists $mi->{$d} and (
          not($cache{$m}) or
          $cache{$m}[0] < $mi->{$d}
        );
    }
  }
  
  # return a reference to the cache
  return \%cache;
}
[download]

my $max_I = maxIntensity($cache, $mass);

sub maxIntensity {
  my ($c, $m) = @_;
  return $c->{sprintf "%.1f", $m}[0];
}
[download]

Hope this helps,

Jeroen
"We are not alone"(FZ)
{1} I have plugged this one quite often the last few months, but it is really a great tool. You can read about my problems at the time here.

sub getIntensity {
   my $mLo = $_[0] – 0.3;
   my $mHi = $_[0] + 0.3;
   my $intensity = 0;
   map { if ($_ >= $mLo && $_ <= $mHi) {
         $intesity = $massint{$_} > $intensity ? $massint{$_} : $inten
+sity}
       } keys %massint;

return $intensity;
}
[download]

Depending on your application, you can trade memory for speed. So if all you are really interested in is the information you extract above, you can pre-calculate and store the results. Or even just cache results like this if you will call repeatably...

my %maxIntesityCache;
sub getIntensity {
  my $m = shift;
  # Do we know this already?
  return $maxIntesityCache{$m}
    if defined $maxIntesityCache{$m};
  ...as for your function, except you can probably change
  the core to remove the exists test and/or one of the other
  suggestions in this thread...
  # Remember this for later
  $maxIntensityCache{$m} = $intensity;
  return $intensity;
}
[download]

Precalculation may give you a win because you can run through the keys once, keeping a window from -0.3 to +0.3 open on your key at all times.

Another thought...if all your numeric work is to precision '0.1' you might get a nice speedup by having your key as 'mass*10' so you are only storing integers. You can then:

• avoid the sprintf you are using to control precision issues, which must hurt you now I come to think of it
• you can switch perl into 'use integer' mode which might help too.

   MeowChow                                   
               s aamecha.s a..a\u$&owag.print

#!/usr/bin/perl -w
$camel = $hump
do {
  theHumpty($camel);
}
[download]