Sequence * declare_sequence ( int min, int max, int nseq)
{
Sequence *LS;
LS=vcalloc (1, sizeof ( Sequence));
LS->seq_comment=declare_char ( nseq,COMMENT_SIZE);
LS->aln_comment=declare_char ( nseq,COMMENT_SIZE);
LS->file=declare_char( nseq,STRING+1);
LS->seq=declare_char ( nseq, max+1);
LS->name=declare_char( nseq,MAXNAMES+1);
LS->len=vcalloc ( nseq, sizeof (int));
LS->max_len=max;
LS->min_len=min;
LS->nseq=nseq;
LS->max_nseq=nseq;
LS->type=vcalloc(30, sizeof (char));
LS->T=declare_arrayN(2, sizeof (Template), nseq, 1);
LS->dc=declare_int (nseq, 2);
return LS;
}
void
compute_oligomer_distance_tree(char *seq_file_name, int* char2value, char *tree_file_name, int max_dist, int word_length, int alphabet_size)
{
int i;
int *compare =(int*) vcalloc(1,sizeof(int));
int *num_seq =(int*) vcalloc(1,sizeof(int));
int num_features = (int)pow(alphabet_size,word_length);
num_features *= num_features * (max_dist+1);
Cluster_info *matrix = feature_extract(seq_file_name, max_dist, word_length, char2value, alphabet_size, compare, num_seq, num_features);
int *node =(int*) vcalloc(1, sizeof(int));
*node = *num_seq;
FILE *tree_f = fopen(tree_file_name,"w");
double *mean = (double*)vcalloc(num_features, sizeof(double));
double *variance = (double*)vcalloc(num_features, sizeof(double));
cluster_recursive(0, *num_seq-1, matrix, num_features, mean, variance, compare, tree_f, node);
for (i = 0; i < *num_seq; ++i)
{
// printf("ERG: %i\n", i);
vfree(matrix[i].features);
}
vfree(matrix);
fclose (tree_f);
vfree(mean);
vfree(variance);
vfree(compare);
vfree(node);
vfree(num_seq);
}
Char_node * declare_char_node (int action)
{
static struct Char_node **heap;
static int heap_size, free_heap, a;
static int key;
if ( action==DECLARE)
{
if ( free_heap==0)
{
free_heap=100;
heap=vrealloc (heap,(heap_size+free_heap)*sizeof (struct Char_node *));
for ( a=heap_size; a<heap_size+free_heap; a++)
{
(heap[a])=vcalloc ( 1, sizeof ( struct Char_node));
(heap[a])->c=vcalloc ( 256, sizeof (Char_node*));
(heap[a])->key=key++;
}
heap_size+=free_heap;
}
return heap[heap_size-(free_heap--)];
}
else if ( action==FREE_STACK)
{
for (a=0; a< heap_size; a++)
{
heap[a]->key=key++;
vfree ( heap[a]->c);
(heap[a])->c=vcalloc ( 256, sizeof (Char_node*));
}
free_heap=heap_size;
return NULL;
}
return NULL;
}
/**
* calculates the number of common tuples
*/
int commonsextet( int *table, int *pointt )
{
int value = 0;
int tmp;
int point;
static int *memo = NULL;
static int *ct = NULL;
static int *cp;
if( !memo )
{
memo =(int*) vcalloc( tsize+1, sizeof( int ) );
ct =(int*) vcalloc( tsize+1, sizeof( int ) );
}
cp = ct;
while( ( point = *pointt++ ) != END_ARRAY )
{
tmp = memo[point]++;
if( tmp < table[point] )
value++;
if( tmp == 0 )
{
*cp++ = point;
}
}
*cp = END_ARRAY;
cp = ct;
while( *cp != END_ARRAY )
memo[*cp++] = 0;
return( value );
}
struct Hasch_data * allocate_ktup_hasch_data (struct Hasch_data *e, int action)
{
static struct Hasch_data **heap;
static int heap_size, free_heap, a;
if ( action == 100)
{
fprintf ( stderr, "\nHeap size: %d, Free Heap: %d", heap_size, free_heap);
return NULL;
}
else if ( action==DECLARE)
{
if ( free_heap==0)
{
free_heap=100;
heap_size+=free_heap;
heap=(Hasch_data**)vrealloc (heap,heap_size*sizeof (struct Hasch_entry *));
for ( a=0; a<free_heap; a++)
{
(heap[a])=(Hasch_data*)vcalloc ( 1, sizeof ( struct Hasch_entry *));
(heap[a])->list=(int*)vcalloc ( 10, sizeof (int));
(heap[a])->list[0]=10;
}
}
return heap[--free_heap];
}
else if ( action==FREE)
{
heap[free_heap++]=e;
e->list[1]=0;
return NULL;
}
return NULL;
}
int * extract_N_diag (int l1, int l2, int **sorted_diag, int n_chosen_diag)
{
int a, b, up, low,current_diag,n_diag;
int * slopes;
int *diag_list;
int window=0;
n_diag=l1+l2-1;
diag_list=vcalloc (l1+l2+1, sizeof (int));
slopes=vcalloc ( n_diag+1, sizeof (int));
for ( a=n_diag; a>0 && a>(n_diag-n_chosen_diag); a--)
{
current_diag=sorted_diag[a][0];
up=MAX(1,current_diag-window);
low=MIN(n_diag, current_diag+window);
for ( b=up; b<=low; b++)slopes[current_diag]=1;
}
slopes[1]=1;
slopes[l1+l2-1]=1;
slopes[l2]=1;
for (a=0; a<= (l1+l2-1); a++)
if ( slopes[a]){diag_list[++diag_list[0]]=a;}
free (slopes);
return diag_list;
}
int * flag_diagonals (int l1, int l2, int **sorted_diag, float T, int window)
{
int a, b, up, low,current_diag,n_diag;
int * slopes;
int *diag_list;
double mean;
double sd;
int use_z_score=1;
n_diag=l1+l2-1;
mean=return_mean_int ( sorted_diag, n_diag+1, 1);
sd =return_sd_int ( sorted_diag, n_diag+1, 1, (int)mean);
if ( T==0)
{
use_z_score=1;
T=(((double)sorted_diag[n_diag][1]-mean)/sd)/25;
}
diag_list=(int*)vcalloc (l1+l2+1, sizeof (int));
slopes=(int*)vcalloc ( n_diag+1, sizeof (int));
for ( a=n_diag; a>0; a--)
{
current_diag=sorted_diag[a][0];
if ( !use_z_score && sorted_diag[a][1]>T)
{
up=MAX(1,current_diag-window);
low=MIN(n_diag, current_diag+window);
for ( b=up; b<=low; b++)slopes[b]=1;
}
else if (use_z_score && ((double)sorted_diag[a][1]-mean)/sd>T)
{
up=MAX(1,current_diag-window);
low=MIN(n_diag, current_diag+window);
for ( b=up; b<=low; b++)slopes[b]=1;
}
else break;
}
for ( a=1, b=0; a<=n_diag; a++)
{
b+=slopes[a];
}
slopes[1]=1;
slopes[l1+l2-1]=1;
slopes[l2]=1;
for (a=0; a<= (l1+l2-1); a++)
if ( slopes[a]){diag_list[++diag_list[0]]=a;}
vfree (slopes);
return diag_list;
}
Decoded_chromosome *get_mem_free_decoded_chrom ( Parameter *PARAM)
{
int a;
if (PARAM->MEM==NULL)
{
PARAM->MEM= vcalloc ( 1, sizeof ( Mem));
(PARAM->MEM)->C_BUF=vcalloc ( 100, sizeof (Decoded_chromosome *));
}
for ( a=0; a< (PARAM->MEM)->NC; a++)
{
if ( ((PARAM->MEM)->C_BUF[a])->used==0)
{
((PARAM->MEM)->C_BUF[a])->used=1;
((PARAM->MEM)->C_BUF[a])->num=a;
return ((PARAM->MEM)->C_BUF[a]);
}
}
(PARAM->MEM)->C_BUF[(PARAM->MEM)->NC]=declare_decoded_chromosome (PARAM);
((PARAM->MEM)->C_BUF[(PARAM->MEM)->NC])->used=1;
((PARAM->MEM)->C_BUF[(PARAM->MEM)->NC])->num=(PARAM->MEM)->NC;
(PARAM->MEM)->NC++;
if ( (PARAM->MEM)->NC>=100)
{
printf ( "\nMEMORY LEAK: TOO MANY DEC CHROM ALLOCATED, FORCED EXIT");
fprintf ((PARAM->BGA)->FP_ERROR, "\nMEMORY LEAK: TOO MANY DEC CHROM ALLOCATED, FORCED EXIT");
crash ( "FORCED EXIT");
}
return ((PARAM->MEM)->C_BUF[(PARAM->MEM)->NC-1]);
}
Oligo * read_oligo_list ( char *fname)
{
Oligo *O;
FILE *fp;
int a, b;
O=vcalloc (1, sizeof (Oligo));
O->ALPHABET=vcalloc ( 100, sizeof (char));
O->EALPHABET=vcalloc ( 100, sizeof (char));
O->AMBIGUITIES=vcalloc ( 100, sizeof (char));
fp=vfopen ( fname, "r");
fscanf ( fp, "ALPHABET %s\n", O->ALPHABET);
fscanf ( fp, "AMBIG_ALPHABET %s\n", O->AMBIGUITIES);
if ( O->AMBIGUITIES[0]=='@')O->AMBIGUITIES[0]='\0';
fscanf ( fp, "WORD_SIZE %d\n", &O->WSIZE);
fscanf ( fp, "NSEQ %d\n", &O->NSEQ);
fscanf ( fp, "LEN %d\n", &O->LEN);
fscanf ( fp, "SCORE %d", &a);
sprintf ( O->EALPHABET, "%s%s", O->ALPHABET, O->AMBIGUITIES);
O->seq=declare_char ( O->NSEQ, O->LEN+1);
for ( a=0; a< O->NSEQ; a++)
{
fscanf ( fp, "%*s\n%s\n",O->seq[a]);
}
vfclose (fp);
return O;
}
void * declare_arrayN (int ndim, size_t size, ...)
{
va_list ap;
int *array;
void **p;
int a;
va_start (ap, size);
array=vcalloc (ndim, sizeof (int));
for ( a=0; a< ndim; a++)
{
array[a]=va_arg (ap,int);
if ( array[a]<0){va_end(ap);return NULL;}
}
va_end (ap);
if ( ndim==2)
{
p=vcalloc_nomemset (array[0], sizeof ( void*));
for (a=0; a< array[0]; a++)
p[a]=vcalloc (array[1], size);
}
else
{
p=declare_arrayN2 (ndim, array, size);
}
vfree (array);
return p;
}
Alignment *declare_Alignment ( Sequence *S)
{
Alignment *LA;
int a;
/*ordre:
[x][0]= which is the xth seq of aln
[x][1]= how many deleted residues before the first one
*/
LA=vcalloc (1, sizeof ( Alignment));
aln_stack (LA, DECLARE_ALN);
if ( S==NULL)
{
LA->declared_len=MAX_LEN_ALN;
LA->max_n_seq=MAX_N_SEQ;
}
else
{
LA->declared_len=2*S->max_len+1;
LA->max_n_seq=S->nseq+1;
}
LA->S=S;
LA->seq_comment=declare_char (LA->max_n_seq, COMMENT_SIZE);
LA->aln_comment=declare_char (LA->max_n_seq, COMMENT_SIZE);
LA->seq_al=declare_char ( LA->max_n_seq,LA->declared_len );
LA->name=declare_char (LA->max_n_seq, MAXNAMES+1);
LA->file=declare_char (LA->max_n_seq, STRING);
LA->tree_order=declare_char (LA->max_n_seq, STRING);
LA->order= declare_int (LA->max_n_seq , 5);
//order[a][0]: sequence index in S
//order[a][1]: offset of the sequence
//order[a][2]: used by sw_gotoh_pair_wise
//order[a][3]: used by sw_gotoh_pair_wise
//order[a][4]: weight, -1
LA->score_seq= vcalloc (LA->max_n_seq, sizeof (int));
for ( a=0; a< LA->max_n_seq; a++)LA->order[a][0]=a;
LA->len_aln=0;
LA->score_aln=0;
LA->len=vcalloc (LA->max_n_seq, sizeof (int));
if (S && S->name)for ( a=0; a<S->nseq; a++)
{
sprintf ( LA->name[a], "%s", S->name[a]);
}
return LA;
}
Mixture * read_dirichlet ( char *name)
{
FILE *fp;
int a,b, c;
float f;
Mixture *D;
D=vcalloc ( 1, sizeof (Mixture));
D->N_COMPONENT=9;
D->ALPHA=vcalloc (9, sizeof (double*));
for ( a=0; a< 9; a++)
D->ALPHA[a]=vcalloc (20, sizeof (double));
D->DM_Q=vcalloc (9, sizeof (double));
if (name!=NULL)
{
fp=vfopen ( name, "r");
for ( a=0; a< 9; a++)
{
fscanf(fp, "%f\n", &f);
D->DM_Q[a]=(double)f;
fscanf(fp, "%f", &f);
for ( b=0; b<20; b++)
{
fscanf(fp, "%f", &f);
D->ALPHA[a][b]=(double)f;
}
fscanf(fp, "\n");
}
for ( a=0; a< 9; a++)
{
fprintf(stderr, "\n%f\n",(float)D->DM_Q[a] );
for ( b=0; b<20; b++)
{
fprintf(stderr, "%f ", (float)D->ALPHA[a][b]);
}
fprintf(stderr, "\n");
}
fprintf ( stderr, "\nN_C=%d",D->N_COMPONENT );
vfclose ( fp);
}
else
{
for (c=0, a=0; a< 9;a++)
{
D->DM_Q[a]=dm[c++];
for (b=0; b<20; b++)
D->ALPHA[a][b]=dm[c++];
}
}
return D;
}
int *code_seq (char *seq, char *type)
{
static int *code;
static int *aa, ng;
int a, b, l;
if (!aa)
{
char **gl;
if ( strm (type, "DNA") || strm (type, "RNA"))
{
gl=declare_char (4,5);
sprintf ( gl[ng++], "Aa");
sprintf ( gl[ng++], "Gg");
sprintf ( gl[ng++], "TtUu");
sprintf ( gl[ng++], "Cc");
}
else
{
gl=make_group_aa ( &ng, "mafft");
}
aa=(int*)vcalloc ( 256, sizeof (int));
for ( a=0; a<ng; a++)
{
for ( b=0; b< strlen (gl[a]); b++)
{
aa[(int)gl[a][b]]=a;
}
}
free_char (gl, -1);
}
l=strlen (seq);
if ( code) code--;
if ( !code || read_array_size (code, sizeof (int))<(l+2))
{
vfree (code);
code=(int*)vcalloc (l+2, sizeof (int));
}
code[0]=ng;
code++;
for (a=0; a<l; a++)
{
code[a]=aa[(int)seq[a]];
}
code[a]=END_ARRAY;
return code;
}
int hasch_seq(char *seq, int **hs, int **lu,int ktup,char *alp)
{
static int a[10];
int i,j,l,limit,code,flag;
char residue;
int alp_lu[10000];
int alp_size;
alp_size=alp[0];
alp++;
for ( i=0; i< alp_size; i++)
{
alp_lu[(int)alp[i]]=i;
}
l=strlen (seq);
limit = (int) pow((double)(alp_size+1),(double)ktup);
hs[0]=(int*)vcalloc ( l+1,sizeof (int));
lu[0]=(int*)vcalloc ( limit+1, sizeof(int));
if ( l==0)myexit(EXIT_FAILURE);
for (i=1;i<=ktup;i++)
a[i] = (int) pow((double)(alp_size+1),(double)(i-1));
for(i=1;i<=(l-ktup+1);++i)
{
code=0;
flag=FALSE;
for(j=1;j<=ktup;++j)
{
if (is_gap(seq[i+j-2])){flag=TRUE;break;}
else residue=alp_lu[(int)seq[i+j-2]];
code+=residue*a[j];
}
if ( flag)continue;
++code;
if (lu[0][code])hs[0][i]=lu[0][code];
lu[0][code]=i;
}
return 0;
}
Fname *declare_fname (int size)
{
Fname *F;
size+=strlen (get_home_4_tcoffee())+FILENAMELEN+1;
F=vcalloc ( 1, sizeof (Fname));
F->name =vcalloc ( size, sizeof (char));
F->path =vcalloc ( size, sizeof (char));
F->suffix=vcalloc ( size, sizeof (char));
F->full=vcalloc ( size, sizeof (char));
return F;
}
Weights* declare_weights ( int nseq)
{
Weights *W;
W=vcalloc ( 1, sizeof ( Weights));
W->comments=vcalloc ( 1000, sizeof (char));
W->nseq=nseq;
W->mode=vcalloc (FILENAMELEN, sizeof (char));
W->seq_name= declare_char ( W->nseq*2, 200);
W->PW_SD=declare_float ( W->nseq, W->nseq);
W->PW_ID=declare_float ( W->nseq, W->nseq);
W->SEQ_W=vcalloc ( W->nseq, sizeof ( float));
return W;
}
Fname *declare_fname (int size){
Fname *F;
size+=1000+FILENAMELEN+1;
F=vcalloc ( 1, sizeof (Fname));
F->name = (char *) vcalloc(size, sizeof (char));
F->path = (char *) vcalloc(size, sizeof (char));
F->suffix= (char *) vcalloc(size, sizeof (char));
F->full= (char *) vcalloc(size, sizeof (char));
return F;
}
int * flag_diagonals (int l1, int l2, int **sorted_diag, float T)
{
int a, b, up, low,current_diag,n_diag;
int * slopes;
int *diag_list;
double mean;
double sd;
int window=0;
n_diag=l1+l2-1;
mean=return_mean_int ( sorted_diag, n_diag+1, 1);
sd =return_sd_int ( sorted_diag, n_diag+1, 1, (int)mean);
if ( T==0)T=(((double)sorted_diag[n_diag][1]-mean)/sd)/10;
diag_list=vcalloc (l1+l2+1, sizeof (int));
slopes=vcalloc ( n_diag+1, sizeof (int));
for ( a=n_diag; a>0; a--)
{
current_diag=sorted_diag[a][0];
if (((double)sorted_diag[a][1]-mean)/sd>T)
{
up=MAX(1,current_diag-window);
low=MIN(n_diag, current_diag+window);
for ( b=up; b<=low; b++)slopes[b]=1;
}
else break;
}
for ( a=1, b=0; a<=n_diag; a++)
{
b+=slopes[a];
}
/* fprintf (stderr, "\nN_DIAG=%d [%.3f]\n]", b, (float)b/((float)n_diag));*/
slopes[1]=1;
slopes[l1+l2-1]=1;
slopes[l2]=1;
for (a=0; a<= (l1+l2-1); a++)
if ( slopes[a]){diag_list[++diag_list[0]]=a;}
free (slopes);
return diag_list;
}
SeqHasch * seq2hasch (int i,char *seq, int ktup, SeqHasch *H)
{
int a,b,l, n=0;
SeqHasch h;
if (!H)
{
H=(hseq**)vcalloc (2, sizeof (SeqHasch));
H[0]=(hseq*)vcalloc (1, sizeof (hseq));
n=1;
}
else
{
n=0;
while (H[++n]);
}
l=strlen (seq);
for (a=0; a<l-ktup; a++)
{
h=H[0];
for (b=a; b<a+ktup; b++)
{
char r;
r=seq[b];
if (!h->hl[r]) h->hl[r]=(hseq*)vcalloc (1, sizeof (hseq));
h=h->hl[r];
}
if (!h->l)
{
h->n=2;
h->l=(int*)vcalloc (2, sizeof (int));
H=(hseq**)vrealloc (H,(n+2)*sizeof (SeqHasch));
H[n]=h;
n++;
}
else
{
h->n+=2;
h->l=(int*)vrealloc (h->l, (h->n)*sizeof (int));
}
h->l[h->n-2]=i;
h->l[h->n-1]=a;
}
return H;
}
int ktup_pair_wise (Alignment *A,int*ns, int **l_s,Constraint_list *CL)
{
static char **gl;
static int ng;
char *seq1;
char *seq2;
int min_len=10;
if ( !gl)
gl=make_group_aa (&ng, "vasiliky");
if ( ns[0]>1)seq1=sub_aln2cons_seq_mat (A, ns[0], l_s[0],"blosum62mt");
else
{
seq1=(char*)vcalloc ( strlen (A->seq_al[l_s[0][0]])+1, sizeof (char));
sprintf ( seq1, "%s",A->seq_al[l_s[0][0]]);
}
if ( ns[1]>1)seq2=sub_aln2cons_seq_mat (A, ns[1], l_s[1],"blosum62mt");
else
{
seq2=(char*)vcalloc ( strlen (A->seq_al[l_s[1][0]])+1, sizeof (char));
sprintf ( seq2, "%s",A->seq_al[l_s[1][0]]);
}
if ( strlen (seq1)<min_len || strlen (seq2)<min_len)
{
Alignment *B;
ungap(seq1); ungap(seq2);
B=align_two_sequences ( seq1, seq2, "blosum62mt",-10, -1, "myers_miller_pair_wise");
A->score=A->score_aln=aln2sim(B, "idmat");
free_aln (B);
return A->score;
}
else
{
string_convert (seq1, ng, gl);
string_convert (seq2, ng, gl);
A->score=A->score_aln=ktup_comparison (seq1,seq2, CL->ktup);
}
vfree (seq1); vfree (seq2);
return A->score;
}
Profile *declare_profile(char *alphabet, int len)
{
Profile *P;
P=vcalloc ( 1, sizeof ( Profile));
P->alp_size=strlen(alphabet);
P->max_len=len;
P->alphabet=vcalloc ( strlen (alphabet)+2, sizeof (char));
sprintf ( P->alphabet, "%s", alphabet);
P->count=declare_int( P->alp_size+2, len);
P->count2=declare_int(100, len);
P->count3=declare_int(100, len);
return P;
}
TC_param * duplicate_TC_param ( TC_param*B)
{
TC_param *N;
N=vcalloc (1, sizeof ( TC_param));
memcpy(B, N, sizeof(TC_param));
return N;
}
int * makepointtable( int *pointt, int *n, int ktup )
{
int point, a, ng;
register int *p;
static int *prod;
ng=n[-1];
if (!prod)
{
prod=(int*)vcalloc ( ktup, sizeof (int));
for ( a=0; a<ktup; a++)
{
prod[ktup-a-1]=(int)pow(n[-1],a);
}
}
p = n;
for (point=0,a=0; a<ktup; a++)
{
point+= *n++ *prod[a];
}
*pointt++ = point;
while( *n != END_ARRAY )
{
point -= *p++ * prod[0];
point *= ng;
point += *n++;
*pointt++ = point;
}
*pointt = END_ARRAY;
return pointt;
}
int weight_motif ( char *motif)
{
int l,a;
static int *lu;
float tot=1;
if (!lu)
{
lu=vcalloc (100, sizeof (int));
lu['A'-'*']=1;
lu['G'-'*']=1;
lu['C'-'*']=1;
lu['T'-'*']=1;
lu['U'-'*']=1;
lu['I'-'*']=2;
lu['Y'-'*']=2;
lu['*'-'*']=4;
}
l=strlen (motif);
for ( a=0; a< l; a++)
{
tot=lu[motif[a]-'*']*tot;
}
tot=(1/tot)*100;
return ((int)tot==0)?1:(int)tot;
}
HaschT * hcreate ( int n_elements,struct Hasch_data * declare_data(struct Hasch_entry *), struct Hasch_data *free_data(struct Hasch_data *) )
{
HaschT *T;
int a;
n_elements=n_elements*2+1;
T=vcalloc ( 1, sizeof (HaschT));
T->ne=n_elements;
T->p=vcalloc (n_elements,sizeof ( Hasch_entry*));
for ( a=0; a<n_elements; a++)
{
T->p[a]=allocate_hasch_entry(NULL,DECLARE,declare_data, free_data);
}
return T;
}
int * extract_N_diag (int l1, int l2, int **sorted_diag, int n_chosen_diag, int window)
{
int a, b, up, low,current_diag,n_diag;
int * slopes;
int *diag_list;
n_diag=l1+l2-1;
diag_list=(int*)vcalloc (l1+l2+1, sizeof (int));
slopes=(int*)vcalloc ( n_diag+1, sizeof (int));
for ( a=n_diag; a>0 && a>(n_diag-n_chosen_diag); a--)
{
current_diag=sorted_diag[a][0];
up=MAX(1,current_diag-window);
low=MIN(n_diag, current_diag+window);
for ( b=up; b<=low; b++)slopes[b]=1;
}
/*flag bottom right*/
up=MAX(1,1-window);low=MIN(n_diag,1+window);
for ( a=up; a<=low; a++) slopes[a]=1;
/*flag top left */
up=MAX(1,(l1+l2-1)-window);low=MIN(n_diag,(l1+l2-1)+window);
for ( a=up; a<=low; a++) slopes[a]=1;
/*flag MAIN DIAG SEQ1*/
up=MAX(1,l1-window);low=MIN(n_diag,l1+window);
for ( a=up; a<=low; a++) slopes[a]=1;
/*flag MAIN DIAG SEQ2*/
up=MAX(1,l2-window);low=MIN(n_diag,l2+window);
for ( a=up; a<=low; a++) slopes[a]=1;
for (a=0; a<= (l1+l2-1); a++)
if ( slopes[a]){diag_list[++diag_list[0]]=a;}
vfree (slopes);
return diag_list;
}
Structure* declare_structure ( int n, char **array)
{
Structure *S;
int a;
S=vcalloc (1, sizeof (Structure));
S->n_fields=1;
S->nseq=n;
S->struc=vcalloc ( n, sizeof (int**));
S->len=vcalloc ( n, sizeof (int));
for ( a=0; a< n; a++)
{
S->len[a]=strlen(array[a]);
S->struc[a]=declare_int ( strlen ( array[a])+2, 1);
}
return S;
}
int ktup_comparison_hasch ( char *i_seq1, char *i_seq2, const int ktup)
{
/*Ktup comparison adapted from Rob Edgar, NAR, vol32, No1, 381, 2004*/
/*1: hasch sequence 1
2: Count the number of seq2 ktup found in seq1
*/
char c;
int key;
static HaschT*H1;
static char *pseq;
Hasch_entry *e;
char *s;
int l, ls;
int p, a, max_dist=-1;
double score=0;
if (!strm (i_seq1, pseq))
{
if (H1)
{
hdestroy (H1, declare_ktup_hasch_data, free_ktup_hasch_data);
string2key (NULL, NULL);
}
H1=hasch_sequence ( i_seq1, ktup);
vfree (pseq);pseq=(char*)vcalloc ( strlen (i_seq1)+1, sizeof (char));
sprintf ( pseq, "%s", i_seq1);
}
ls=l=strlen (i_seq2);
s=i_seq2;
p=0;
while (ls>ktup)
{
c=s[ktup];s[ktup]='\0';
key=string2key (s, NULL);
e=hsearch (H1,key,FIND, declare_ktup_hasch_data, free_ktup_hasch_data);
if ( e==NULL);
else if ( max_dist==-1)score++;
else
{
for ( a=1; a<=(e->data)->list[1]; a++)
if (FABS((p-(e->data)->list[a]))<=max_dist)
{score++; break;}
}
s[ktup]=c;s++;p++;ls--;
}
score/=(l-ktup);
score=(log(0.1+score)-log(0.1))/(log(1.1)-log(0.1));
if ( score>100) score=100;
return (int)(score*100);
}
int vthread_create(vthread_t *thread, vthread_attr_t *attr,
vthread_routine start_routine, void *arg, int argsize)
{
int ret = ESUCCESS;
vthread_t vthread;
/**
* SIGCHLD must be catched to wake up the server when a client terminated.
*/
struct sigaction action;
action.sa_flags = SA_SIGINFO;
sigemptyset(&action.sa_mask);
//action.sa_sigaction = handler;
/**
* ignore SIGCHLD allows the child to die without to create a zombie.
* But the parent doesn't receive information.
* See below about "waitpid"
*/
action.sa_handler = SIG_IGN;
sigaction(SIGCHLD, &action, NULL);
vthread = vcalloc(1, sizeof(struct vthread_s));
if (vthread && (vthread->pid = fork()) == 0)
{
#ifdef TIME_PROFILER
struct timeval date1, date2;
gettimeofday(&date1, NULL);
#endif
ret = (int)start_routine(arg);
#ifdef TIME_PROFILER
gettimeofday(&date2, NULL);
date2.tv_sec -= date1.tv_sec;
if (date2.tv_usec > date1.tv_usec)
date2.tv_usec -= date1.tv_usec;
else
{
date2.tv_sec += 1;
date2.tv_usec = date1.tv_usec - date2.tv_usec;
}
printf("time %d:%d\n", date2.tv_sec, date2.tv_usec);
#endif
exit(ret);
}
else if ( (vthread == NULL) || (vthread->pid == -1))
{
err("fork error %s", strerror(errno));
ret = EREJECT;
}
else
{
sched_yield();
*thread = vthread;
}
return ret;
}
double float_logB (float *i, int n)
{
static double *array;
int a;
if ( array==NULL)array=vcalloc ( 1000, sizeof (double));
for ( a=0; a< n; a++)
array[a]=(double)i[a];
return double_logB(array, n);
}
