annotate source/fastq_pair_array.c @ 0:816cb55b5a2d draft default tip

planemo upload for repository https://github.com/portiahollyoak/Tools commit c4769fd68ad9583d4b9dbdf212e4ecb5968cef1c-dirty

1 /****************************************************************************
2  * The 'FASTQ_PAIR_ARRAY' structure group was used to store a array of 
3  * paired FASTQ reads, including basic operation function as well.
4  *
5  * This file was written by Haibin Xu, December 2011.
6  ****************************************************************************/
7 
8 #include "fastq_pair_array.h"
9 
10 FASTQ_PAIR_ARRAY *fastq_pair_array_create()
11 {
12     /* create a FASTQ pair array. If successful, return the point to it, 
13      * otherwise, return NULL.
14      */
15     FASTQ_PAIR_ARRAY *fq_pair_array;
16     
17     if((fq_pair_array=(FASTQ_PAIR_ARRAY *)malloc(sizeof(FASTQ_PAIR_ARRAY)))==NULL)
18         return NULL;
19     
20     if((fq_pair_array->array=
21 		(FASTQ_PAIR_ARRAY_BLOCK *)malloc(sizeof(FASTQ_PAIR_ARRAY_BLOCK)))==NULL)
22 	{
23 		free(fq_pair_array);
24 		return NULL;
25 	}
26     
27 	fq_pair_array->last=fq_pair_array->array;
28 	fq_pair_array->block_num=1;
29 	fq_pair_array->fastq_pair_num=0;
30 	
31 	fq_pair_array->array->previous=NULL;
32 	fq_pair_array->array->next=NULL;
33 	fq_pair_array->array->num=0;
34 	
35 	fq_pair_array->index=NULL;
36 	
37     return fq_pair_array;
38 }
39 
40 int fastq_pair_array_remove(FASTQ_PAIR_ARRAY *fq_pair_array)
41 {
42     /* free the FASTQ pair array. If successful, return 0, otherwise 
43      * return 1.
44      */
45     long i;
46 	FASTQ_PAIR_ARRAY_BLOCK *fq_pair_array_block;
47 	
48 	if(fq_pair_array==NULL)
49 		return 1;
50 	
51 	fq_pair_array_block=fq_pair_array->last;
52 	for(;fq_pair_array_block!=NULL;)
53 	{
54 		for(i=0;i<fq_pair_array_block->num;i++)
55 			fastq_pair_remove(fq_pair_array_block->block[i]);
56 		
57 		fq_pair_array_block=fq_pair_array_block->previous;
58 	}
59 	
60 	if(fq_pair_array->index!=NULL)
61 		free(fq_pair_array->index);
62 	
63     return 0;
64 }
65 
66 int fastq_pair_array_append(FASTQ_PAIR *fq_pair, FASTQ_PAIR_ARRAY *fq_pair_array)
67 {
68     /* append a new FASTQ pair to the array. if successful, return 0, otherwise
69      * return 1.
70 	 */
71 	FASTQ_PAIR_ARRAY_BLOCK *block_temp;
72 	
73 	if(fq_pair_array==NULL || fq_pair==NULL)
74 		return 1;
75 	
76 	if(fq_pair_array->last->num<FASTQ_PAIR_ARRAY_BLOCK_SIZE)
77 	{
78 		/* append to the last array_block */
79 		fq_pair_array->last->block[fq_pair_array->last->num++]=fq_pair;
80 		fq_pair_array->fastq_pair_num++;
81 	}
82 	else
83 	{
84 		/* add a new array_block, amd append to it */
85 		if((block_temp=
86 			(FASTQ_PAIR_ARRAY_BLOCK *)malloc(sizeof(FASTQ_PAIR_ARRAY_BLOCK)))==NULL)
87 			return 0;
88 		
89 		fq_pair_array->last->next=block_temp;
90 		block_temp->previous=fq_pair_array->last;
91 		fq_pair_array->last=block_temp;
92 		fq_pair_array->block_num++;
93 		
94 		block_temp->num=0;
95 		block_temp->block[block_temp->num++]=fq_pair;
96 		fq_pair_array->fastq_pair_num++;
97 	}
98 	
99     return 0;
00 }
01 
02 int fastq_pair_array_generate_index(FASTQ_PAIR_ARRAY *fq_pair_array)
03 {
04 	/* generate the index for given FASTQ_PAIR, if successful, return 0, otherwise
05 	 * return 1.
06 	 */
07 	FASTQ_PAIR_ARRAY_BLOCK **temp_index;
08 	FASTQ_PAIR_ARRAY_BLOCK *fq_array_block;
09 	long i;
10 	
11 	if(fq_pair_array==NULL)
12 		return 1;
13 	
14 	if(fq_pair_array->index!=NULL)
15 	{
16 		free(fq_pair_array->index);
17 		fq_pair_array->index=NULL;
18 	}
19 	
20 	if((temp_index=(FASTQ_PAIR_ARRAY_BLOCK **)malloc(sizeof(FASTQ_PAIR_ARRAY_BLOCK *)*(fq_pair_array->block_num)))==NULL)
21         return 1;
22 	
23 	fq_array_block=fq_pair_array->array;
24 	for(i=0;i<fq_pair_array->block_num;i++)
25 	{
26 		temp_index[i]=fq_array_block;
27         fq_array_block=fq_array_block->next;
28 	}
29 	
30 	fq_pair_array->index=temp_index;
31 	
32 	return 0;
33 	
34 }
35 
36 FASTQ_PAIR **fastq_pair_array_get_pointer(FASTQ_PAIR_ARRAY *fq_pair_array, long position)
37 {
38     /* get double pointer to individual fastq_pair member at specific position
39      * in the array, if successful, return the double pointer, otherwise
40      * return NULL
41      */
42     FASTQ_PAIR_ARRAY_BLOCK *fq_array_block;
43     long block_num, num;
44     long i;
45     
46     if(fq_pair_array==NULL || position<=0 || position>fq_pair_array->fastq_pair_num)
47         return NULL;
48     
49     block_num=position/FASTQ_PAIR_ARRAY_BLOCK_SIZE;
50     num=position%FASTQ_PAIR_ARRAY_BLOCK_SIZE;
51 	
52     if(num==0)
53         num=FASTQ_PAIR_ARRAY_BLOCK_SIZE;
54     else
55         block_num++;
56     
57 	if(fq_pair_array->index==NULL)
58 	{
59 		fq_array_block=fq_pair_array->array;
60 		for(i=1;i<block_num;i++)
61 			fq_array_block=fq_array_block->next;
62 		
63 		return &fq_array_block->block[num-1];
64 	}
65     else
66 		return &fq_pair_array->index[block_num-1]->block[num-1];
67 	
68 	return NULL;
69 }
70 
71 int fastq_pair_array_merge(FASTQ_PAIR_ARRAY *fq_pair_array,
72 						   FASTQ_PAIR_ARRAY *temp_fq_pair_array, 
73 						   long low, long middle, long high)
74 {
75     /* merge the two sorted part in array, low-middle and middle-high, into a 
76      * single sorted order. If successful, return 0, otherwise return 1.
77 	 */
78     long i, begin1, end1, begin2, end2;
79     FASTQ_PAIR **fq_pair_current1, **fq_pair_current2;
80     FASTQ_PAIR **temp_fq_pair_current;
81 	
82     if(fq_pair_array==NULL || temp_fq_pair_array==NULL || 
83 	   low > middle || middle > high || 
84 	   fq_pair_array->fastq_pair_num!=temp_fq_pair_array->fastq_pair_num)
85 		return 1;
86 	
87 	begin1=low;
88     end1=middle;
89     begin2=middle+1;
90     end2=high;
91 	
92 	/* merge processing */
93     for(i = low; begin1 <= end1 && begin2 <= end2;i++)
94     {
95         fq_pair_current1=fastq_pair_array_get_pointer(fq_pair_array, begin1);
96         fq_pair_current2=fastq_pair_array_get_pointer(fq_pair_array, begin2);
97         
98         temp_fq_pair_current=fastq_pair_array_get_pointer(temp_fq_pair_array, i);
99 
00         if(fastq_pair_compare_tight(*fq_pair_current1, *fq_pair_current2)<=0)
01         {
02             *temp_fq_pair_current=*fq_pair_current1;
03             begin1++;
04         }
05         else
06         {
07             *temp_fq_pair_current=*fq_pair_current2;
08             begin2++;
09         }
10     }
11     
12 	/* moving the remaining data to temp_fq_pair_array */
13     if(begin1<=end1)
14     {
15         for(;begin1<=end1;)
16         {
17             temp_fq_pair_current=fastq_pair_array_get_pointer(temp_fq_pair_array, i++);
18             fq_pair_current1=fastq_pair_array_get_pointer(fq_pair_array, begin1++);
19             *temp_fq_pair_current=*fq_pair_current1;
20         }
21     }
22     if(begin2<=end2)
23     {
24 		for(;begin2<=end2;)
25 		{
26 			temp_fq_pair_current=fastq_pair_array_get_pointer(temp_fq_pair_array, i++);
27 			fq_pair_current2=fastq_pair_array_get_pointer(fq_pair_array, begin2++);
28 			*temp_fq_pair_current=*fq_pair_current2;
29 		}
30     }
31     
32 	/* moving the merged data to original position 'fq_pair_array' */
33     for(i=low;i<=high;i++)
34     {
35         fq_pair_current1=fastq_pair_array_get_pointer(fq_pair_array, i);
36         temp_fq_pair_current=fastq_pair_array_get_pointer(temp_fq_pair_array, i);
37         *fq_pair_current1=*temp_fq_pair_current;
38     }
39 	
40 	return 0;
41 }
42 
43 int fastq_pair_array_sort(FASTQ_PAIR_ARRAY *fq_pair_array, FASTQ_PAIR_ARRAY *temp_fq_pair_array,
44 								long first, long last)
45 {
46     /* sort the FASTQ pair array. If successful, return 0, otherwise
47      * return 1
48      */
49 	long mid;
50     
51     if(first<last)
52     {
53         mid=(first+last)/2;
54         fastq_pair_array_sort(fq_pair_array, temp_fq_pair_array, first, mid);
55         fastq_pair_array_sort(fq_pair_array, temp_fq_pair_array, mid+1, last);
56         fastq_pair_array_merge(fq_pair_array, temp_fq_pair_array, first, mid, last);
57     }
58     
59     return 0;
60 }
61 
62 int fastq_pair_array_printf(FASTQ_PAIR_ARRAY *fq_pair_array, FILE *fp_out1, FILE *fp_out2,
63                             char *format, int serial_flag, int flag_uniq)
64 {
65     /* write the pair-end reads in the array in FASTA or FASTQ format into two 
66      * output files(format='fa' or 'fq')  or in FASTA format into a single output
67      * file(format="fa" and fp_out2==NULL) using the original description 
68      * (serial_flag=0) or a new serial number(serial_flag=1). Output all sequences
69 	 * (flag_uniq==0), or unique ones(flag_uniq==1). If successful, return 0,
70 	 * otherwise return 1.
71      */
72     long i, k;
73     FASTQ_PAIR **temp_fq_pair, **temp_fq_pair_old;
74     
75     if(flag_uniq==0)
76     {
77         for(i=1;i<=fq_pair_array->fastq_pair_num;i++)
78         {
79             temp_fq_pair=fastq_pair_array_get_pointer(fq_pair_array, i);
80             
81             if(serial_flag==0)
82                 fastq_pair_printf(*temp_fq_pair, fp_out1, fp_out2, format, -1);
83             else
84                 fastq_pair_printf(*temp_fq_pair, fp_out1, fp_out2, format, i);
85         }
86     }
87     else
88     {
89 		temp_fq_pair_old=fastq_pair_array_get_pointer(fq_pair_array, 1);
90 
91 		/* the fastq_pair_array contain only one read-pair, output it */
92 		if(fq_pair_array->fastq_pair_num==1)
93 		{
94 			if(serial_flag==0)
95 				fastq_pair_printf(*temp_fq_pair_old, fp_out1, fp_out2,
96 								  format, -1);
97 			else
98 				fastq_pair_printf(*temp_fq_pair_old, fp_out1, fp_out2,
99 								  format, k++);
00 		}
01 		
02 		/* compare and output */
03         for(i=2, k=1;i<=fq_pair_array->fastq_pair_num;i++)
04         {
05 			temp_fq_pair=fastq_pair_array_get_pointer(fq_pair_array, i);
06             if(fastq_pair_compare_loose(*temp_fq_pair_old, *temp_fq_pair)!=0)
07             {
08                 if(serial_flag==0)
09                     fastq_pair_printf(*temp_fq_pair_old, fp_out1, fp_out2,
10                                       format, -1);
11                 else
12                     fastq_pair_printf(*temp_fq_pair_old, fp_out1, fp_out2,
13                                       format, k++);
14 				
15 				temp_fq_pair_old=temp_fq_pair;
16 				
17 				if(i==fq_pair_array->fastq_pair_num)
18 				{
19 					if(serial_flag==0)
20 						fastq_pair_printf(*temp_fq_pair, fp_out1, fp_out2,
21 										  format, -1);
22 					else
23 						fastq_pair_printf(*temp_fq_pair, fp_out1, fp_out2,
24 										  format, k++);
25 				}
26             }
27             else
28             {
29                 if(fastq_pair_get_left_length(*temp_fq_pair_old) <= fastq_pair_get_left_length(*temp_fq_pair) &&
30                    fastq_pair_get_right_length(*temp_fq_pair_old) <= fastq_pair_get_right_length(*temp_fq_pair))
31 				{
32                     temp_fq_pair_old=temp_fq_pair;
33 
34 					if(i==fq_pair_array->fastq_pair_num)
35 					{
36 						if(serial_flag==0)
37 							fastq_pair_printf(*temp_fq_pair, fp_out1, fp_out2,
38 											  format, -1);
39 						else
40 							fastq_pair_printf(*temp_fq_pair, fp_out1, fp_out2,
41 											  format, k++);
42 					}
43 				}
44                 else
45                 {
46                     if(serial_flag==0)
47                         fastq_pair_printf(*temp_fq_pair_old, fp_out1, fp_out2,
48                                           format, -1);
49                     else
50                         fastq_pair_printf(*temp_fq_pair_old, fp_out1, fp_out2,
51                                           format, k++);
52                     
53                     temp_fq_pair_old=temp_fq_pair;
54                 }
55             }
56         }
57     }
58     return 0;
59 }
60 
61 
62 
63 
64 
65 
66 
67 
68 
69 
70 
71 
72 
73 
74 
75 
76 
77 
78