push (my @arrayEquals, @array);
[download]

to:

       push (@arrayEquals, @array);
[download]

I don't completely understand your requirements either, but I'll take a stab. You'll probably end up with multiple arrays of arrays, right -- one for each unique value in the first column? In other words, for the value KN-1791-LAST_rep_c7834 you could have an array of arrays, but then there will be another for the next different value found in column 1, and so on. In that case, I suspect you really want a hash of arrays of arrays (HoAoA), keyed on that column 1 value. Or perhaps, once you've built an array of arrays for a particular column 1 value, you can go ahead and print it out or do whatever you need to do with it, and be done with it? I can't really tell.

It's also not clear what you mean by "a difference of 10", since you didn't give an example like that, and I don't know what you mean by a "false positive." Maybe you could give a longer sample of your input data (10-12 lines) and what you would expect the output to look like, and get some advice on the best way to get there.

One likely problem, code-wise: this line (below) doesn't make an array of arrays, as you may be expecting. It pushes the values in the second array onto the end of the first array, leaving it one-dimensional. To get an array of arrays, you would push a reference to your sub-array onto the first one, like in my second line:

   push (@arrayEquals, @array); # just makes the array longer

   push @arrayEquals, [@array]; # makes an array of arrays
[download]

First, you use just s/\r?\n//;, but perhaps you meant $line =~ s/\r?\n//;

You've been given excellent feedback. I agree with aaron_baugher that a hash of arrays of arrays (HoAoA) is likely a good fit for your program. With that in mind, consider the following:

use Modern::Perl;
use Data::Dumper;

my %HoAoArrays;

while (<DATA>) {
    chomp;
    my ( $col0, @cols1_3 ) = split /\t/;
    push @{ $HoAoArrays{$col0} }, \@cols1_3;
}

for my $key ( keys %HoAoArrays ) {
    my $numElements= @{ $HoAoArrays{$key} };
    
    for ( my $i = 0 ; $i < $numElements; $i++ ) {
        say '${ $HoAoArrays{' 
          . $key . '} }[' 
          . $i
          . ']->[1] = '
          . ${ $HoAoArrays{$key} }[$i]->[1];
    }

    say '';
}

say '', Dumper \%HoAoArrays;

__DATA__
KN-1791-LAST_rep_c7834    IMGA|Medtr4g125100.1    2e-139    497
KN-1791-LAST_rep_c7834    IMGA|Medtr4g125100.1    4e-46    187
KN-1791-LAST_rep_c7834    IMGA|Medtr4g125100.2    4e-46    187
KN-1792-LAST_rep_c7834    IMGA|Medtr4g125100.1    2e-150    497
KN-1792-LAST_rep_c7834    IMGA|Medtr4g125100.1    4e-37    187
KN-1792-LAST_rep_c7834    IMGA|Medtr4g125100.2    4e-37    187
KN-1792-LAST_rep_c7834    IMGA|Medtr4g125100.3    4e-35    188
[download]

Output:

${ $HoAoArrays{KN-1792-LAST_rep_c7834} }[0]->[1] = 2e-150
${ $HoAoArrays{KN-1792-LAST_rep_c7834} }[1]->[1] = 4e-37
${ $HoAoArrays{KN-1792-LAST_rep_c7834} }[2]->[1] = 4e-37
${ $HoAoArrays{KN-1792-LAST_rep_c7834} }[3]->[1] = 4e-35

${ $HoAoArrays{KN-1791-LAST_rep_c7834} }[0]->[1] = 2e-139
${ $HoAoArrays{KN-1791-LAST_rep_c7834} }[1]->[1] = 4e-46
${ $HoAoArrays{KN-1791-LAST_rep_c7834} }[2]->[1] = 4e-46

$VAR1 = {
          'KN-1792-LAST_rep_c7834' => [
                                        [
                                          'IMGA|Medtr4g125100.1',
                                          '2e-150',
                                          '497'
                                        ],
                                        [
                                          'IMGA|Medtr4g125100.1',
                                          '4e-37',
                                          '187'
                                        ],
                                        [
                                          'IMGA|Medtr4g125100.2',
                                          '4e-37',
                                          '187'
                                        ],
                                        [
                                          'IMGA|Medtr4g125100.3',
                                          '4e-35',
                                          '188'
                                        ]
                                      ],
          'KN-1791-LAST_rep_c7834' => [
                                        [
                                          'IMGA|Medtr4g125100.1',
                                          '2e-139',
                                          '497'
                                        ],
                                        [
                                          'IMGA|Medtr4g125100.1',
                                          '4e-46',
                                          '187'
                                        ],
                                        [
                                          'IMGA|Medtr4g125100.2',
                                          '4e-46',
                                          '187'
                                        ]
                                      ]
        };
[download]

The while loop splits each tab-delimited line into a scalar ($col0) and an array (@cols1_3). The @{} notation enclosing the hash (i.e., @{ $HoAoArrays{$col0} }) tells perl to treat it as an array, and an array reference is pushed onto it.

The subsequent for loop shows how to deference the array references. Finally, Dumper is used to visually represent the created data structure: { } = hash and [ ] = array. Dumper shows a hash with two keys. Each key has a corresponding array as its value, and each array has arrays as its elements (HoAoA).

Hope this helps!

I too am uncertain about your objective, but from what I see I suspect your solution is more complicated than it needs to be. The following is much simpler, and might be what you want. If not, it might be a basis for modification to get what you want. To that end, I suggest starting with something simple that works, and then making one change at a time to make it closer to what you want, making sure your program runs as expected at each step.

Anyway, here is something you might consider:

use strict;
use warnings;
use Data::Dumper;

my $minimum_difference = 10;

my $input_filename  = 'e_d.txt';
open(my $input_fh, '<', $input_filename) or die "$input_filename: $!";


my $previous_fields;

while (my $line = <$input_fh>) {
    chomp($line);

    my $fields = [ split(/\t/, $line) ];

    if(
        defined($previous_fields) and
        $previous_fields->[0] eq $fields->[0] and
        $previous_fields->[1] ne $fields->[1] and
        $previous_fields->[-2] - $fields->[-2] < $minimum_difference
    ) {
        print "Failed test:\n" . Dumper([ $previous_fields, $fields ])
+ . "\n\n";
    }

    $previous_fields = $fields;
}
[download]

I have made many assumptions. Most significant is the assumption that you are only interested in differences between consecutive lines in the input file.

I have used Data::Dumper to dump both arrays of fields when the test fails. This module is very helpful when you are developing code that deals with data structures. You also might want to read perldsc.

Thanks so much for the great replies, going to give things an overhaul for sure, and I'll know how to clarify things for future questions! Thanks again

I don't use BioPerl and I really don't know what the possibilities are. But I would start with: Google Perl Blast.

I feel like I'm not using everything Perl has to offer , is probably right! Bio Informatics and Perl fit very well together. Perl can do a lot more than just solve this problem "at hand". I think that you will find more powerful tools than we can present here for the "problem of the day".