Shell Programming and Scripting

while (@fileA)  #open the file
{
   chomp;
   @lineFile1Array = split (/\t/,$_);   #split the line into temporary array elements
   @tempStart = split (/,/,$lineArray[5]);
   @tempEnd = split (/,/,$lineArray[6]);
   my @newLineArray;
   while ($count > $lineArray[4])   # changed this to ">" - the number in the file might be 1-6
                                    # but we'd have array elements 0-5
   {
      # - we grab the first element from [5] and the first element from [6]
      ###############Array construction removed - not needed
      while $line(@fileB)
      {
         @lineFile2Array = split (/\t/,$line);
          if (($lineFile2Array[1] >= $tempStart[$count]) && ($lineFile2Array[2] <= $tempEnd[$count]))
         {
            #This is where you will write the code to create your new file
            #Match found = write to yourfile
         }
      # If no match found (or when done evaluating that element)
      $count++;     # We increment afterward, so that the next time that the evaluation
                    # of $count > $lineArray[4], we should stop if we've reached the
                    # number of pairs for this line.
      }
   # If no match found, (or when done evaluating that line) move on to the next line in file2
   }
# If no match found, move on to the next line in file2
}

   my @newLineArray;

#!/usr/bin/perl -w

################################################################################
################################################################################
# What this script does:                                                       #
# This script can be used to compare data overlap                              #
#                                                                              #
# How this script works:                                                       #
# It parses two external files and identifies which line entries fall within   #
# the match statement.                                                         #
#                                                                              #
# Where this script is run (and by whom):                                      #
# This script should be run from a host where the files can be accessed for    #
# comparison                                                                   #
#                                                                              #
# Revision history:                                                            #
# September 15, 2008                                                           #
#    AKG - File creation                                                       #
################################################################################
################################################################################


################################################################################
################################################################################
# Define Pragma                                                                #
################################################################################
################################################################################
use strict;
use Getopt::Std;
use vars qw/ %opt /;
use Time::HiRes qw(gettimeofday);

################################################################################
# Define Variables                                                             #
################################################################################
#my $dir        = "/usr/local/overlap"; # base directory
my $dir        = "/opt/home/agray/scripting/overlap"; # base directory
my $DEBUG;
my @tm;
my $logfile;
my $timeStamp;
my @fileA;
my @fileB;
my $count;
my @lineFile1Array;
my @lineFile2Array;
my @tempStart;
my @tempEnd;
my $line;

################################################################################
# Define Prerequisites  (Require / Include statements go here)                 #
################################################################################

################################################################################
# Forward declaration of subroutines                                           #
################################################################################
sub do_init();              # This manages the command line options
sub do_usage();             # This is the usage message for do_init()

################################################################################
################################################################################
# MAIN                                                                         #
################################################################################
################################################################################

# Parse command line variables                                                 #
do_init();

# set DEBUG flag according to command line options                             #
if ( $opt{d} )
{
   $DEBUG = 1;
}
else
{
   $DEBUG = 0;
}

# Next, create a timestamp and logfile to store information                    #
# getTimestamp
@tm = (localtime($^T))[0..5];
++$tm[4];
$tm[5] += 1900;
$timeStamp = sprintf("%04d%02d%02d.%02d%02d%02d", reverse @tm);
$logfile = "$dir/log/$0.$timeStamp.log";

open LOG, ">> $logfile" or die "Can't open $logfile for write: $!";
print LOG "$timeStamp: running $0\n";


################################################################################
# Open files into array                                                        #
################################################################################

open(FILEA, "<$opt{a}") or die "Cannot open $opt{a} for read :$!";
@fileA = <FILEA>;
close( FILEA );

open(FILEB, "<$opt{b}") or die "Cannot open $opt{b} for read :$!";
@fileB = <FILEB>;
close( FILEB );


# Open the first file
foreach (@fileA)
{
   chomp;
   $count = 0;
   @lineFile1Array = split /\t/,$_;   #split the line into temporary array elements
   my $numberOfElements = $lineFile1Array[4];
   @tempStart = split /,/,$lineFile1Array[5];
   @tempEnd = split /,/,$lineFile1Array[6];
   while ($count < $numberOfElements)
   {
      # changed this to lessthan - the number in the file might be 6 but we have array elements 0-5
      # We grab the first element from [5] and the first element from [6]
      foreach (@fileB)
      {
         @lineFile2Array = split /\t/,$_;
         if (($lineFile2Array[1] >= $tempStart[$count]) && ($lineFile2Array[2] <= $tempEnd[$count]))
         {
            print LOG "Match!   $lineFile2Array[1] ~ $tempStart[$count]\n";
            print LOG "Match!   $lineFile2Array[2] ~ $tempEnd[$count]\n";
         }
      # when done evaluating that element
      }
   # If no match found, (or when done evaluating that line) move on to the next line in file2
   $count++;     # We increment afterward, so that the next time that the evaluation
                 # of $count > $lineArray[4], we should stop if we've reached the
                 # number of pairs for this line.
   }
# If no match found, move on to the next line in file2
}

close( LOG );




################################################################################
################################################################################
# Subroutines                                                                  #
################################################################################
################################################################################
sub do_init()
{
   my $opt_string = 'hda:b:';
   getopts( "$opt_string", \%opt ) or do_usage();
   do_usage() if $opt{h};
   do_usage() unless ($opt{a} && $opt{b});
}


sub do_usage()
{
   print "\nusage: $0 [-h] [-d] [-a file1] [-b file2]\n\n";
   #############################################################################
   print "\n\n";
   exit;
}

20080915.134301: running ./overlap.pl
Match!   100208130 ~ 100208127
Match!   100208166 ~ 100208306
Match!   100231689 ~ 100231680
Match!   100231725 ~ 100231885

awk '
NR==FNR {
   seg_count++;
   Segs[seg_count, "min"  ] = $3;
   Segs[seg_count, "max"  ] = $4;
   Segs[seg_count, "count"] = $5;

   split($6, smin, /,/);
   split($7, smax, /,/);

   for (i=1; i<=$5; i++) {
      Segs[seg_count, i, "min"] = smin[i];
      Segs[seg_count, i, "max"] = smax[i]
   }

   next;
}
{
   for (s=1; s<=seg_count; s++) {
      if ($2 >= Segs[s, "min"] && $3 <= Segs[s, "max"]) {
         for (i=1; i<=Segs[s, "count"]; i++) {
            if ($2 >= Segs[s, i, "min"] && $3 <= Segs[s, i, "max"]) {
               printf("YES %s => Match line #%d segment #%d : %d,%d\n",
                      $0, s, i, Segs[s, i, "min"], Segs[s, i, "max"]);
               next;
            }
         }
      }
   }
   printf("NO  %s\n", $0);
}

' labrazil_1.dat labrazil_2.dat

YES 1    100208130       100208166       + => Match line #1 segment #1 : 100208127,100208306
NO  1    100208310       100208346       +
YES 1    100217090       100217126       + => Match line #2 segment #1 : 100217082,100217185
YES 1    100231689       100231725       + => Match line #1 segment #2 : 100231680,100231885

#!/bin/sh
# file1 = smaller file2 = large file
set -x
tr -s ',' ' ' < file1 | nl |\
awk '{ for(i=7; i<NF; i++) {j=i+1; print $1, $i, $j} }' | \
 sort -n -k1.1,1.6 -k2.1,2.10 > filea
 
 
nl file2 | awk '{print $1, $3, $4 }' | \
  sort -n -k2.1,2.10 > fileb

wc -l filea | read maxrow1 dummy
wc -l fileb | read maxrow2 dummy

if [ -x ./overlap ]; then
  overlap filea $maxrow1 fileb $maxrow2  > results.txt
else
   # gcc -o overlap overlap.c
   cc -o overlap overlap.c
   overlap filea $maxrow1 fileb $maxrow2 > results.txt
fi   
echo "results.txt created"
exit 0

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define chk(x) if ( (x)==NULL){ perror("memory error"); exit(1);}
/*******************
*      overlap calculation - 
* usage: overlap <small_filename> <linecount> <big_filename> <linecount>
* run in overlap.sh
* output to stdout
* assume at least 32 bit int
********************/

typedef
struct 
{
	unsigned long row;
	unsigned long val1;
	unsigned long val2;
} row_t;


/* return NULL if not overlap 
* overlap == any number in the range of sm->val1 .. sm->val2  is 
*                equal to or inside any number in 
*                the range of big->val1 ..big->val2 or
*            there exists at least one common number in each range.
*/
const row_t *show_overlap(const row_t *sm, const row_t *big)
{
    
    int retval=0;
    if(sm->row && big->row) 
    {   /* greatest sm number is less than least big number
    	*  or smallest sm number is bigger than greatest big number        
    	*/
		retval=(sm->val2 <  big->val1 || sm->val1 > big->val2)? 0: 1;
		if(retval)
	   		printf("%d: %d  %d\n", sm->row, big->val1, big->val2);
	}
	return (retval)? sm : NULL;
}
char **whack( char **arr, char *src, const char *delimiter)
{   
	int i=0;
	char *p=strtok(src, delimiter);
	while(p!=NULL  && i < 4)
	{
		arr[i++]=p;
		arr[i]=NULL;
		p=strtok('\0', delimiter);
	}                                                             
    return arr;                                              
}

void load(row_t *b,  FILE *fp)
{
	char tmp[256]={0x0};
	while(fgets(tmp, sizeof(tmp), fp)!=NULL)
	{
	    char *p[8]={NULL};  
	    whack(p, tmp, " ");
		b->row= strtoul(p[0], NULL, 10);
		b->val1=strtoul(p[1], NULL, 10);
		b->val2=strtoul(p[2], NULL, 10);
		b++;
	}
	b->row=b->val1=b->val2=0;
	fclose(fp);
}

void overlap(row_t *sm, row_t *bg)
{
	
	register row_t *p=bg;
	while(sm->row)
	{   
	
		while(sm->val2 < p->val1 && p->row) p++;
		while(show_overlap(sm, p) !=NULL) p++;		    			
		sm++;
		if(sm->row) /* back further down big as needed */
		   while(p->val2 >= sm->val1 && p>bg) p--;
	}
}

void disp(row_t *p, char *a)
{    int i=0;
	while(p->row)
	{
		printf("%s i=%d %d %d %d \n", 
		    a, i, p->row, p->val1, p->val2);
	    p++;	i++;
	}	
	
}

int process(FILE *sm, const int count1, 
            FILE *bg, const int count2)
{

    row_t *big=malloc(sizeof(row_t) * count2);
	row_t *small=malloc(sizeof(row_t) * count1);
	
	chk(small); /* memory check */
	chk(big);	
	
	load(big, bg);  /* create array of structs */
	load(small, sm);
/*	disp(big, "big"); turn on to see what is being loaded */
/*	disp(small, "small"); */
	
	overlap(small, big); /* print overlaps */
	free(small);
	free(big);
	return 0;
}

int main(int argc, char **argv)
{
	if(argc == 5)
	{
		int count1=0;
		int count2=0;
	    FILE *sm=fopen(argv[1], "r");
	    FILE *bg=fopen(argv[3], "r");		
		if(sm == NULL || bg == NULL)
		{		    
		    perror("Cannot open input files");
		    exit(1);
		}
		count1=atoi(argv[2]);
		count2=atoi(argv[4]);
		count1++; count2++;
		process(sm, count1, bg, count2);		  
	}
	else
	{
		printf("Invalid number of arguments\n");
		exit(1);
	}
	return 0;
}

time overlap filea $maxrow1 fileb $maxrow2  > /dev/null
real    0m1.51s
user    0m0.44s
sys     0m0.30s

retval=(sm->val2 <  big->val1 || sm->val1 > big->val2)? 0: 1;