If your area is "sparse", that is, the number of regions is far smaller than the number of points in your space, I think using arithmetic instead of a bitmask will be much faster.

The two regions can be ordered by the numerical order of their lower bound, and if the two are equal, by their upper bound. Two regions then overlap iff the lower bound of the upper region is smaller than the upper bound of the lower region.

Alternatively, if you have many one-dimensional regions, or regions with holes in them, and a large space, like Unicode has, Inversion Lists (also greping big numbers) might be a good approach to do fast set operations.

Apart from that I agree with Corion that inversion lists are a good technique for this sort of problem.

#!/usr/bin/perl -l

my $region1=[[1,2],[5,7]];
my $region2=[[2,6]];

sub max {
    return $_[0] > $_[1] ? $_[0] : $_[1];
}

sub min {
    return $_[0] < $_[1] ? $_[0] : $_[1];
}

sub getIntersect {
    my ($reg1, $reg2) = @_;

    return if $reg1->[1] < $reg2->[0];
    return if $reg1->[0] > $reg2->[1];

    return (max($reg1->[0], $reg2->[0]), min($reg1->[1], $reg2->[1]));
}


foreach my $r1 (@$region1) {
    foreach my $r2 (@$region2) {
        if( my @is = getIntersect($r1, $r2) ) {
            print "[$is[0], $is[1]]";
        }
    }
}


[download]

See vec. By using bitstrings instead of bytestrings, your masks will be 1/8th the size (and the boolean operations a lot faster).

With a million random generated intervals, using bytestrings consumed nearly 2 GB and 80+ seconds; the same intervals using bitstrings only 0.6GB and 40 seconds.

C:\test>797136-a -INTERVALS=1e6
Check mem: 1.975 GB ( 82 seconds )

C:\test>797136-b -INTERVALS=1e6
Check mem: 0.616 GB ( 44 seconds )
[download]

BTW: Yourcodewouldbealoteasiertoreadandeditifitcontained a few spaces!