What have you tried? There is a neat trick you can use in Perl to make it easy to mock up a few files that may help you get started on a solution. Consider:

use strict;
use warnings;

my $file1Str = <<FILEDATA;
Alex 3 44
Barry 2 44
James 6 45
Drew 9 43
Alex 124 175
FILEDATA

my $file2Str = <<FILEDATA;
James 1 22
Alex 89 120
Alex 134 155
Barry 12 24
FILEDATA

my $file3Str = <<FILEDATA;
Alex 154 174
James 29 45
Drew 19 54
Drew 139 154
FILEDATA

open my $fileIn, '<', \$file1Str;
print "Prim: $_" for <$fileIn>;
close $fileIn;

for my $secFile ($file2Str, $file3Str) {
    open my $secIn, '<', \$secFile;
    print "Sec: $_" for <$secIn>;
}
[download]

Prints:

Prim: Alex 3 44
Prim: Barry 2 44
Prim: James 6 45
Prim: Drew 9 43
Prim: Alex 124 175
Sec: James 1 22
Sec: Alex 89 120
Sec: Alex 134 155
Sec: Barry 12 24
Sec: Alex 154 174
Sec: James 29 45
Sec: Drew 19 54
Sec: Drew 139 154
[download]

The trick is using a string as an input file by passing a reference to it in place of a file name in the open statement. That allows you to easily include several tests "files" in your source code so you can easily play around with test data. It also makes it really easy for us to reproduce your results when you ask a question concerning your code.

my %master = (
 Alex => [ [3,44], [124,175] ],
 Barry => [ [2,44] ],
 # more data here #
);
[download]

my $some_name = 'Alex';
foreach my $range ( @{$master{$some_name}} ){
  my ($start, $end) = @$range;
  print "$start, $end\n";
}
[download]

use Modern::Perl;

use Number::Range;
use Text::CSV::Auto qw( process_csv );
use Data::Dump qw /dump/;

my $debug = 0;
my %database;
process_csv('./primary.txt',
    sub {
        my $row = shift;
        push @{$database{$row->{name}}}, [$row->{start}, $row->{end}];
    }
);
say dump(\%database) if $debug;

analyse ('./secondary_1.txt');
analyse ('./secondary_2.txt');

sub analyse {
    my $file = shift;
    my %data;
    process_csv($file,
        sub {
            my $row = shift;
            push @{$data{$row->{name}}}, [$row->{start}, $row->{end}];
        }
    );
    say dump(\%data) if $debug;
    for my $name (sort keys %data) {
        unless ($database{$name}) {
            say "Unknown name '$name'";
            next;
        }
        for my $range_ref (@{$database{$name}}) {
            print "$name: $range_ref->[0] $range_ref->[1] ";
            my $range = Number::Range->new($range_ref->[0] .. $range_r
+ef->[1]);
            for my $testrange_ref (@{$data{$name}}) {
                if ($range->inrange(@$testrange_ref)) {
                    print "present $testrange_ref->[0] $testrange_ref-
+>[1] ";
                }
                else {
                    print "absent 0 0 ";
                }
            }
            print "\n";
        }
    }
}
[download]

Output:

Alex: 3 44 absent 0 0 absent 0 0 
Alex: 124 175 absent 0 0 present 134 155 
Barry: 2 44 present 12 24 
James: 6 45 absent 0 0
Alex: 3 44 absent 0 0 
Alex: 124 175 present 154 174 
Drew: 9 43 present 19 54 absent 0 0 
James: 6 45 present 29 45
[download]

This solution suffers from the same problem you already mentioned: it checks all ranges and finds that some ranges in the secondary files are outside of the ranges in the primary file (see the data for "Alex"). But unless you find a good rule to define which ranges in the secondary files are to be checked against which ranges in the primary files, there is no way to solve this problem.

Oh and BTW, it is "Perl" (the language) or "perl" (the executable), but never ever "PERL". :)

Hi CountZero,

Thanks for your posting, I think its pretty close to what I was hoping to produce as an output

Since I've never used such complicated code before, I was not very successful at modifying it for my exact purpose (see below) Could you please help out again with a modification of your Perl script? (not PERL) :)

It looks like, in the output you generated, you did more than compare 1 primary file to all secondary files, but I cant say for sure

Could you help out by modifying your code so that the output is in tabular form for ONLY the primary to EACH secondary file comparison, and no reciprocal comparisons of secondary to primary, or one secondary to another secondary file?

Also, I think in your example output using your script, for Drew and Barry the comparisons for one of the secondary files is missing, only one set of entries is present.. Is that fixed easily?

In terms of range comparison, it is very simple math, but I think you have that implemented right. Anyways, described below:

In the original data file, as a rule, ALWAYS p1<p2, and S1-1 < S1-2, and S2-1 < S2-2

If primary range is numerically p1 to p2 and for secondary ranges they are S1-1 to S1-2 (for 1st secondary file), S2-1 to S2-2 (for 2nd secondary file), then simply

S1-1 >= p1

S1-1 <= p2

S1-2 >= p1

S1-2 <= p2

This means the range S1-1 to S1-2 is nested within the range p1 to p2, or can be the same, but any extension past the primary range is disallowed... Likewise for any other range, S2-1 to S2-2 for another file....Therefore, again

S2-1 >= p1

S2-1 <= p2

S2-2 >= p1

S2-2 <= p2

Thanks again CountZero

I see where I went wrong.

I checked the secondary files against the primary file (analyse subroutine), rather than the other way around. Easy enough to switch that:

use Modern::Perl;

use Number::Range;
use Text::CSV::Auto qw( process_csv );
use Data::Dump qw /dump/;

my $debug = 0;
my %database;
process_csv('./primary.txt',
    sub {
        my $row = shift;
        push @{$database{$row->{name}}}, [$row->{start}, $row->{end}];
    }
);
say dump(\%database) if $debug;

analyse ('./secondary_1.txt');
analyse ('./secondary_2.txt');

sub analyse {
    my $file = shift;
    say "--Checking $file--";
    my %data;
    process_csv($file,
        sub {
            my $row = shift;
            push @{$data{$row->{name}}}, [$row->{start}, $row->{end}];
        }
    );
    say dump(\%data) if $debug;
    for my $name (sort keys %database) {
        unless ($data{$name}) {
            for my $range_ref (@{$database{$name}}) {
                say "$name: $range_ref->[0] $range_ref->[1]  absent 0 
+0";
            }
            next;
        }
        for my $range_ref (@{$database{$name}}) {
            print "$name: $range_ref->[0] $range_ref->[1] ";
            my $range = Number::Range->new($range_ref->[0] .. $range_r
+ef->[1]);
            for my $testrange_ref (@{$data{$name}}) {
                if ($range->inrange(@$testrange_ref)) {
                    print "present $testrange_ref->[0] $testrange_ref-
+>[1] ";
                }
                else {
                    print "absent 0 0 ";
                }
            }
            print "\n";
        }
    }
    say '------------------------------';
}
[download]

Which produces the following output:

--Checking ./secondary_1.txt--
Alex: 3 44 absent 0 0 absent 0 0 
Alex: 124 175 absent 0 0 present 134 155 
Barry: 2 44 present 12 24 
Drew: 9 43  absent 0 0
James: 6 45 absent 0 0 
------------------------------
--Checking ./secondary_2.txt--
Alex: 3 44 absent 0 0 
Alex: 124 175 present 154 174 
Barry: 2 44  absent 0 0
Drew: 9 43 present 19 54 absent 0 0 
James: 6 45 present 29 45 
------------------------------
[download]

The whole range checking is done thanks to the Number::Range module. Please, check out its documentation and more specifically the inrange-method called in scalar context. I hand it the begin and endpoints of the range to be checked and if both are within the range to be checked against, it returns true, hence the whole range must be within.

The analyse subroutine in the script above takes as its only argument the filename of a "secondary" file and the primary file is checked against this secondary file. There is no secondary-against-secondary checking done or a reciprocal secondary against primary. Check the main for-loop inside this subroutine: it uses the data in the %database-hash which has been populated with the data from the primary file.

CountZero

A program should be light and agile, its subroutines connected like a string of pearls. The spirit and intent of the program should be retained throughout. There should be neither too little or too much, neither needless loops nor useless variables, neither lack of structure nor overwhelming rigidity." - The Tao of Programming, 4.1 - Geoffrey James