length(@{$matches{$element}{$site}} looks rather surprising to me. Consider:

my @array = ('bannana', 'apple', 'orange');

print length (@array);
[download]

Prints '1'. Most likely what you really wanted was the number of elements in the array. That is simple @array in a scalar context. However is seems like you really want to iterate over the array so a beter construct would be:

for my $low (@{$matches{$element}{$site}}) {
[download]

and omit the following line initialising $low. There are a number of places where the same thing seems to have been done.

Other changes I'd make involve early exits from loops rather than nesting inside if statements, removing duplicated code, removing superfluious nexts, using Perl for loops rather than C for loops and adding a little vertical whitespace to make flow clearer. At the end of that process I get:

my @fastarray;
my %matches;
my %sets;
my $span;

for my $element (@fastarray) {
    my $setscounter = 0;

    next unless defined %{$matches{$element}};

    for my $site (sort {$a <=> $b } keys %{$matches{$element}}) {
        next unless @{$matches{$element}{$site}};

        for my $low (@{$matches{$element}{$site}}) {
            my $lowerlimit = $low + 0;
            my $upperlimit = $span + $lowerlimit;
            
            for my $sitekey (sort {$a <=> $b } keys %{$matches{$elemen
+t}}) {
                next unless @{$matches{$element}{$sitekey}};
                
                my @arrayA = ();
                
                for my $hElem (@{$matches{$element}{$sitekey}}) {
                    print "...in \$hElem\n";
                    if ($hElem >= $lowerlimit && $hElem <= $upperlimit
+) {
                        push (@arrayA, $hElem);
                    }
                }
                
                if (@arrayA) {
                    $sets{$element}[$setscounter]{$sitekey} = \@arrayA
+;
                    print "\$sets{$element}[$setscounter] is:\n";
                    print Dumper(%{$sets{$element}[$setscounter]});
                    @arrayA = ();
                } else {
                    $sets{$element}[$setscounter]{$sitekey} = undef;
                }
            }
            
            $setscounter++;
        }
    }
}
[download]

which may or may not be nothing at all like what you intended ;).

Thanks. That looks really great.

I've been playing with it, and I did hit one snag so far. The arrays sotred in @{$matches{$element}{$sitekey}} contain possibly millions of elements, all stored in numerical order. If we assume that the ones being pushed into @arrayA are going to number a dozen or less, it seems really wasteful to me to sift through the entire array, for instance, once you've already reached values >= $upperlimit.

This is why I had included some of the early loop exits and so on. It will (presumaby) greatly increase the speed of the program, which is highly desirable. What are your thoughts on modifying your code here:

for my $hElem (@{$matches{$element}{$sitekey}}) {
    print "...in \$hElem\n";
    if ($hElem >= $lowerlimit && $hElem <= $upperlimit) {
        push (@arrayA, $hElem);
        }
    }
[download]

To something along these lines instead? :

for my $hElem (@{$matches{$element}{$sitekey}}) {
    next unless ($hElem >= $lowerlimit);
    break unless ($hElem <= $upperlimit);
    print "...in \$hElem\n"   
    push (@arrayA, $hElem);
    }
[download]

Thanks,
Matt

The loop with early exit looks fine. However if there are large numbers of elements and the range represents a small fraction of the total number of elements, then I'd be inclined to do a binary search for the two end elements in the range and use an array slice to copy the elements in the range out. You may find Binary search helps as a starting point for the search code.

Given two end element indexes the following does the slice and copy:

@arrayA = @{$matches{$element}{$sitekey}}[$first .. $last];
[download]

---

DWIM is Perl's answer to Gödel

          if (@arrayA && $hit == length(@{$matches{$fastarray[$h]}{$si
+tekey}})) {
            $sets{$fastarray[$h]}[$setscounter]{$sitekey} = \@arrayA;
            print "\$sets{$fastarray[$h]}[$setscounter] is:\n";
            print Dumper(%{$sets{$fastarray[$h]}[$setscounter]}); 
            @arrayA = ();
            }
[download]

for my $fastarray ( @fastarray ) {
    my $hash = $matches{ $fastarray };

    for my $site ( sort { $a <=> $b } keys %$hash ) {

        for my $lowerlimit ( @{ $hash->{ $site } } ) {
            my $upperlimit = $span + $lowerlimit;

            for my $sitekey ( sort { $a <=> $b } keys %$hash ) {
                push @{ $sets{ $fastarray } }, { $sitekey => undef };
                my @arrayA = grep { $_ >= $lowerlimit && $_ <= $upperl
+imit } @{ $hash->{ $sitekey } }
                    or next;
                $sets{ $fastarray }[ -1 ]{ $sitekey } = \@arrayA;
                print "\$sets{$fastarray}[-1] is:\n", Dumper $sets{ $f
+astarray }[ -1 ];
                }
            }
        }
[download]

First of all, before you do anything else, put the following 2 lines at the top of your program:

use strict;
use warnings;
[download]

Now run your program, and get the output:

Global symbol "@fastarray" requires explicit package name at x line 5.
Global symbol "$setscounter" requires explicit package name at x line 
+6.
Global symbol "%matches" requires explicit package name at x line 7.
Global symbol "@fastarray" requires explicit package name at x line 7.
Global symbol "$site" requires explicit package name at x line 8.
Global symbol "%matches" requires explicit package name at x line 8.
Global symbol "@fastarray" requires explicit package name at x line 8.
Global symbol "%matches" requires explicit package name at x line 9.
Global symbol "@fastarray" requires explicit package name at x line 9.
Global symbol "$site" requires explicit package name at x line 9.
Global symbol "$i" requires explicit package name at x line 10.
Global symbol "$i" requires explicit package name at x line 11.
Global symbol "%matches" requires explicit package name at x line 11.
Global symbol "@fastarray" requires explicit package name at x line 11
+.
Global symbol "$site" requires explicit package name at x line 11.
Global symbol "$lowerlimit" requires explicit package name at x line 1
+2.
Global symbol "%matches" requires explicit package name at x line 13.
Global symbol "@fastarray" requires explicit package name at x line 13
+.
Global symbol "$site" requires explicit package name at x line 13.
# ... etc. ...
[download]

Now go and fix those problems; declare each symbol in the outermost scope that they are needed.  For example:

my @fastarray;
my @fastarray;
my $setscounter;
my %matches;
my $site;
my %sets;
                                                                      
+          
FASTA: for (my $h=0;$h<(@fastarray);$h++) {
[download]

You shouldn't ever have to declare the same variable twice (otherwise, it's like using a whole different variable).

That should give you some clues about where your problem is.

Hi. I guess I should have mentioned this in my original post. The section of code that I pasted in here is actually a subset of a subroutine of a much larger program. I am using use strict and use warnings.

The code itself functions and does not give any warnings (even when I run perl -w). It's just that it's not running the way I want it to.

I know I should probably run it through perl -d, but considering how far down the pipe in the program this section actually occurs, It'd take me 20 minutes just to get to this point.

Thanks though, for the thought.
Matt