If you mean to run the script with a long list of R/P file names then this will do it. Note as the P names are derived from the R names you only need give a list of R names. If the extension is always the same a list of base names would do, should be trivial to get there from here.

#!/usr/bin/perl
use strict;
use warnings;

for (@ARGV) {
    next if /P\./; # ignore the P files
    my ($base, $ext)= split /R/; #assume only one 'R' in the file name
    r_p_process ( $base."R".$ext, $base."P".$ext )
}

sub r_p_process {
    my $r_file=shift;
    my $p_file=shift;
    print "processing the pair $r_file $p_file\n";
    # do your funky stuff
}
[download]

Cheers,
R.

Hi Random Walk,
Thanks so much answering. I've tested your code. It works great.
Just wonder how can I modify the code, such that it capture the file automatically.

Currently I have to pass the all files argument manually like this:

perl mycode.pl data1P.fa data1R.fa data2P.fa data2R.fa ....etc
[download]

Because there are many many files like this. Can it be automated?

Regards,
Edward

Something like that (untested code):

#!/usr/bin/perl
use strict;
use warnings;

for ( glob data*R.fa ) {
    my $Rfile = $_;
    s/R(?=\.fa)$/P/;
    my $Pfile = $_;
        # Your code here
}
[download]

# All "R" data files
my @data_r = glob "*R.fa";
# All "P" data files
my @data_p = glob "*P.fa";
[download]

You can get the base datafile names like this:

my @base_data = map substr($_, 0, length($_) - 4), @data_r;
[download]

#!c:\perl\bin\perl.exe
use strict;
use File::Recurse; 
use File::Find;

my (@filearr, $path, $prod_file, $files, %files, %all);

sub recurse
{
    my $path=shift;
    my $matchpattern=shift;
    %files = Recurse(["$path"], 
    {
        match => "$matchpattern", nomatch => ''
    });             
    if (scalar keys %all)
    {
        @all{keys %files} = values %files;
    }
    else
    {
        %all=%files;
    }    
}

{
    recurse("c:\\data", "\.");
    
    foreach (sort keys %all) 
    { 
        my $dirs=$_;
        foreach (@{ $all{"$_"} }) 
        { 
            $files=$_;
            my $fullname="$dirs"."\\"."$files";
            push @filearr, "$fullname\n";
        }
    }    
      
    foreach my $machine (@filearr)
    {
        chomp;
        open FH, "<$machine";
        my $ctr=0;
        foreach (<FH>)
        {
            chomp;
            $ctr+=$_;
        }
        close FH;
        $all{$machine}=$ctr;
    }    
}
[download]

If you decide to go with File::Find and are Unix find savvy, check out the handy find2perl script. Write a find command line that does what you want and then replace 'find' with 'find2perl' and it will generate the code for you.

Although for your specific task, File::Find may be overkill. The various glob solutions others have posted should serve you well.

my $file_r = $ARGV[0];
my $file_r = $ARGV[1];
open FILE_R, "< $file_r" or die "Can't open $file_r : $!";
open FILE_P, "< $file_p" or die "Can't open $file_p : $!";
[download]

while (<FILE_R>){
  chomp;
  push @rdata, $_;
}

while (<FILE_R>){
  chomp;
  push @rdata, $_;
}

my @sum = map {$rdata[$_] + $pdata[$_]} 0..$_#a;
[download]

Please note that while it's easy to understand what your code could be supposed to do, the above simply won't compile, and it's advisable to post minimal, but complete, working samples of code.

As a side note, since basically you trust your files to hold the same number of entries, you could avoid putting all of their contents into arrays to process them later (this basically amounts to -unnecessary- slurping) and process them sequentially instead...