RNAlib-2.2.0RC0
gquad.h
Go to the documentation of this file.
1 #ifndef __VIENNA_RNA_PACKAGE_GQUAD_H__
2 #define __VIENNA_RNA_PACKAGE_GQUAD_H__
3 
5 
6 #ifndef INLINE
7 #ifdef __GNUC__
8 # define INLINE inline
9 #else
10 # define INLINE
11 #endif
12 #endif
13 
20 int E_gquad(int L,
21  int l[3],
22  paramT *P);
23 
24 FLT_OR_DBL exp_E_gquad( int L,
25  int l[3],
26  pf_paramT *pf);
27 
28 int E_gquad_ali(int i,
29  int L,
30  int l[3],
31  const short **S,
32  int n_seq,
33  paramT *P);
34 
35 
36 void E_gquad_ali_en( int i,
37  int L,
38  int l[3],
39  const short **S,
40  int n_seq,
41  int en[2],
42  paramT *P);
43 
60 int *get_gquad_matrix(short *S, paramT *P);
61 
62 int *get_gquad_ali_matrix(short *S_cons,
63  short **S,
64  int n_seq,
65  paramT *P);
66 
67 FLT_OR_DBL *get_gquad_pf_matrix( short *S,
68  FLT_OR_DBL *scale,
69  pf_paramT *pf);
70 
71 int **get_gquad_L_matrix( short *S,
72  int start,
73  int maxdist,
74  int **g,
75  paramT *P);
76 
77 void get_gquad_pattern_mfe(short *S,
78  int i,
79  int j,
80  paramT *P,
81  int *L,
82  int l[3]);
83 
84 void
85 get_gquad_pattern_exhaustive( short *S,
86  int i,
87  int j,
88  paramT *P,
89  int *L,
90  int *l,
91  int threshold);
92 
93 void get_gquad_pattern_pf( short *S,
94  int i,
95  int j,
96  pf_paramT *pf,
97  int *L,
98  int l[3]);
99 
100 plist *get_plist_gquad_from_pr( short *S,
101  int gi,
102  int gj,
103  FLT_OR_DBL *G,
104  FLT_OR_DBL *probs,
105  FLT_OR_DBL *scale,
106  pf_paramT *pf);
107 plist *get_plist_gquad_from_pr_max(short *S,
108  int gi,
109  int gj,
110  FLT_OR_DBL *G,
111  FLT_OR_DBL *probs,
112  FLT_OR_DBL *scale,
113  int *L,
114  int l[3],
115  pf_paramT *pf);
116 
117 plist *get_plist_gquad_from_db( const char *structure,
118  float pr);
119 
120 int get_gquad_count(short *S,
121  int i,
122  int j);
123 
124 int get_gquad_layer_count(short *S,
125  int i,
126  int j);
127 
128 
139 int parse_gquad(const char *struc, int *L, int l[3]);
140 
141 
142 
160 INLINE PRIVATE int backtrack_GQuad_IntLoop(int c,
161  int i,
162  int j,
163  int type,
164  short *S,
165  int *ggg,
166  int *index,
167  int *p,
168  int *q,
169  paramT *P){
170 
171  int energy, dangles, k, l, maxl, minl, c0, l1;
172  short si, sj;
173 
174  dangles = P->model_details.dangles;
175  si = S[i + 1];
176  sj = S[j - 1];
177  energy = 0;
178 
179  if(dangles == 2)
180  energy += P->mismatchI[type][si][sj];
181 
182  if(type > 2)
183  energy += P->TerminalAU;
184 
185  k = i + 1;
186  if(S[k] == 3){
187  if(k < j - VRNA_GQUAD_MIN_BOX_SIZE){
188  minl = j - i + k - MAXLOOP - 2;
189  c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
190  minl = MAX2(c0, minl);
191  c0 = j - 3;
192  maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
193  maxl = MIN2(c0, maxl);
194  for(l = minl; l < maxl; l++){
195  if(S[l] != 3) continue;
196  if(c == energy + ggg[index[l] + k] + P->internal_loop[j - l - 1]){
197  *p = k; *q = l;
198  return 1;
199  }
200  }
201  }
202  }
203 
204  for(k = i + 2;
205  k < j - VRNA_GQUAD_MIN_BOX_SIZE;
206  k++){
207  l1 = k - i - 1;
208  if(l1>MAXLOOP) break;
209  if(S[k] != 3) continue;
210  minl = j - i + k - MAXLOOP - 2;
211  c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
212  minl = MAX2(c0, minl);
213  c0 = j - 1;
214  maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
215  maxl = MIN2(c0, maxl);
216  for(l = minl; l < maxl; l++){
217  if(S[l] != 3) continue;
218  if(c == energy + ggg[index[l] + k] + P->internal_loop[l1 + j - l - 1]){
219  *p = k; *q = l;
220  return 1;
221  }
222  }
223  }
224 
225  l = j - 1;
226  if(S[l] == 3)
227  for(k = i + 4;
228  k < j - VRNA_GQUAD_MIN_BOX_SIZE;
229  k++){
230  l1 = k - i - 1;
231  if(l1>MAXLOOP) break;
232  if(S[k] != 3) continue;
233  if(c == energy + ggg[index[l] + k] + P->internal_loop[l1]){
234  *p = k; *q = l;
235  return 1;
236  }
237  }
238 
239  return 0;
240 }
241 
258 INLINE PRIVATE int backtrack_GQuad_IntLoop_L(int c,
259  int i,
260  int j,
261  int type,
262  short *S,
263  int **ggg,
264  int maxdist,
265  int *p,
266  int *q,
267  paramT *P){
268 
269  int energy, dangles, k, l, maxl, minl, c0, l1;
270  short si, sj;
271 
272  dangles = P->model_details.dangles;
273  si = S[i + 1];
274  sj = S[j - 1];
275  energy = 0;
276 
277  if(dangles == 2)
278  energy += P->mismatchI[type][si][sj];
279 
280  if(type > 2)
281  energy += P->TerminalAU;
282 
283  k = i + 1;
284  if(S[k] == 3){
285  if(k < j - VRNA_GQUAD_MIN_BOX_SIZE){
286  minl = j - i + k - MAXLOOP - 2;
287  c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
288  minl = MAX2(c0, minl);
289  c0 = j - 3;
290  maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
291  maxl = MIN2(c0, maxl);
292  for(l = minl; l < maxl; l++){
293  if(S[l] != 3) continue;
294  if(c == energy + ggg[k][l - k] + P->internal_loop[j - l - 1]){
295  *p = k; *q = l;
296  return 1;
297  }
298  }
299  }
300  }
301 
302  for(k = i + 2;
303  k < j - VRNA_GQUAD_MIN_BOX_SIZE;
304  k++){
305  l1 = k - i - 1;
306  if(l1>MAXLOOP) break;
307  if(S[k] != 3) continue;
308  minl = j - i + k - MAXLOOP - 2;
309  c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
310  minl = MAX2(c0, minl);
311  c0 = j - 1;
312  maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
313  maxl = MIN2(c0, maxl);
314  for(l = minl; l < maxl; l++){
315  if(S[l] != 3) continue;
316  if(c == energy + ggg[k][l - k] + P->internal_loop[l1 + j - l - 1]){
317  *p = k; *q = l;
318  return 1;
319  }
320  }
321  }
322 
323  l = j - 1;
324  if(S[l] == 3)
325  for(k = i + 4;
326  k < j - VRNA_GQUAD_MIN_BOX_SIZE;
327  k++){
328  l1 = k - i - 1;
329  if(l1>MAXLOOP) break;
330  if(S[k] != 3) continue;
331  if(c == energy + ggg[k][l - k] + P->internal_loop[l1]){
332  *p = k; *q = l;
333  return 1;
334  }
335  }
336 
337  return 0;
338 }
339 
340 INLINE PRIVATE
341 int
342 E_GQuad_IntLoop(int i,
343  int j,
344  int type,
345  short *S,
346  int *ggg,
347  int *index,
348  paramT *P){
349 
350  int energy, ge, dangles, p, q, l1, minq, maxq, c0;
351  short si, sj;
352 
353  dangles = P->model_details.dangles;
354  si = S[i + 1];
355  sj = S[j - 1];
356  energy = 0;
357 
358  if(dangles == 2)
359  energy += P->mismatchI[type][si][sj];
360 
361  if(type > 2)
362  energy += P->TerminalAU;
363 
364  ge = INF;
365 
366  p = i + 1;
367  if(S[p] == 3){
368  if(p < j - VRNA_GQUAD_MIN_BOX_SIZE){
369  minq = j - i + p - MAXLOOP - 2;
370  c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
371  minq = MAX2(c0, minq);
372  c0 = j - 3;
373  maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
374  maxq = MIN2(c0, maxq);
375  for(q = minq; q < maxq; q++){
376  if(S[q] != 3) continue;
377  c0 = energy + ggg[index[q] + p] + P->internal_loop[j - q - 1];
378  ge = MIN2(ge, c0);
379  }
380  }
381  }
382 
383  for(p = i + 2;
384  p < j - VRNA_GQUAD_MIN_BOX_SIZE;
385  p++){
386  l1 = p - i - 1;
387  if(l1>MAXLOOP) break;
388  if(S[p] != 3) continue;
389  minq = j - i + p - MAXLOOP - 2;
390  c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
391  minq = MAX2(c0, minq);
392  c0 = j - 1;
393  maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
394  maxq = MIN2(c0, maxq);
395  for(q = minq; q < maxq; q++){
396  if(S[q] != 3) continue;
397  c0 = energy + ggg[index[q] + p] + P->internal_loop[l1 + j - q - 1];
398  ge = MIN2(ge, c0);
399  }
400  }
401 
402  q = j - 1;
403  if(S[q] == 3)
404  for(p = i + 4;
405  p < j - VRNA_GQUAD_MIN_BOX_SIZE;
406  p++){
407  l1 = p - i - 1;
408  if(l1>MAXLOOP) break;
409  if(S[p] != 3) continue;
410  c0 = energy + ggg[index[q] + p] + P->internal_loop[l1];
411  ge = MIN2(ge, c0);
412  }
413 
414 #if 0
415  /* here comes the additional stuff for the odd dangle models */
416  if(dangles % 1){
417  en1 = energy + P->dangle5[type][si];
418  en2 = energy + P->dangle5[type][sj];
419  en3 = energy + P->mismatchI[type][si][sj];
420 
421  /* first case with 5' dangle (i.e. j-1) onto enclosing pair */
422  p = i + 1;
423  if(S[p] == 3){
424  if(p < j - VRNA_GQUAD_MIN_BOX_SIZE){
425  minq = j - i + p - MAXLOOP - 2;
426  c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
427  minq = MAX2(c0, minq);
428  c0 = j - 4;
429  maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
430  maxq = MIN2(c0, maxq);
431  for(q = minq; q < maxq; q++){
432  if(S[q] != 3) continue;
433  c0 = en1 + ggg[index[q] + p] + P->internal_loop[j - q - 1];
434  ge = MIN2(ge, c0);
435  }
436  }
437  }
438 
439  for(p = i + 2; p < j - VRNA_GQUAD_MIN_BOX_SIZE; p++){
440  l1 = p - i - 1;
441  if(l1>MAXLOOP) break;
442  if(S[p] != 3) continue;
443  minq = j - i + p - MAXLOOP - 2;
444  c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
445  minq = MAX2(c0, minq);
446  c0 = j - 2;
447  maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
448  maxq = MIN2(c0, maxq);
449  for(q = minq; q < maxq; q++){
450  if(S[q] != 3) continue;
451  c0 = en1 + ggg[index[q] + p] + P->internal_loop[l1 + j - q - 1];
452  ge = MIN2(ge, c0);
453  }
454  }
455 
456  q = j - 2;
457  if(S[q] == 3)
458  for(p = i + 4; p < j - VRNA_GQUAD_MIN_BOX_SIZE; p++){
459  l1 = p - i - 1;
460  if(l1>MAXLOOP) break;
461  if(S[p] != 3) continue;
462  c0 = en1 + ggg[index[q] + p] + P->internal_loop[l1 + 1];
463  ge = MIN2(ge, c0);
464  }
465 
466  /* second case with 3' dangle (i.e. i+1) onto enclosing pair */
467 
468  }
469 #endif
470  return ge;
471 }
472 
473 INLINE PRIVATE
474 int *
475 E_GQuad_IntLoop_exhaustive( int i,
476  int j,
477  int **p_p,
478  int **q_p,
479  int type,
480  short *S,
481  int *ggg,
482  int threshold,
483  int *index,
484  paramT *P){
485 
486  int energy, *ge, dangles, p, q, l1, minq, maxq, c0;
487  short si, sj;
488  int cnt = 0;
489 
490  dangles = P->model_details.dangles;
491  si = S[i + 1];
492  sj = S[j - 1];
493  energy = 0;
494 
495  if(dangles == 2)
496  energy += P->mismatchI[type][si][sj];
497 
498  if(type > 2)
499  energy += P->TerminalAU;
500 
501  /* guess how many gquads are possible in interval [i+1,j-1] */
502  *p_p = (int *)space(sizeof(int) * 256);
503  *q_p = (int *)space(sizeof(int) * 256);
504  ge = (int *)space(sizeof(int) * 256);
505 
506  p = i + 1;
507  if(S[p] == 3){
508  if(p < j - VRNA_GQUAD_MIN_BOX_SIZE){
509  minq = j - i + p - MAXLOOP - 2;
510  c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
511  minq = MAX2(c0, minq);
512  c0 = j - 3;
513  maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
514  maxq = MIN2(c0, maxq);
515  for(q = minq; q < maxq; q++){
516  if(S[q] != 3) continue;
517  c0 = energy + ggg[index[q] + p] + P->internal_loop[j - q - 1];
518  if(c0 <= threshold){
519  ge[cnt] = energy + P->internal_loop[j - q - 1];
520  (*p_p)[cnt] = p;
521  (*q_p)[cnt++] = q;
522  }
523  }
524  }
525  }
526 
527  for(p = i + 2;
528  p < j - VRNA_GQUAD_MIN_BOX_SIZE;
529  p++){
530  l1 = p - i - 1;
531  if(l1>MAXLOOP) break;
532  if(S[p] != 3) continue;
533  minq = j - i + p - MAXLOOP - 2;
534  c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
535  minq = MAX2(c0, minq);
536  c0 = j - 1;
537  maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
538  maxq = MIN2(c0, maxq);
539  for(q = minq; q < maxq; q++){
540  if(S[q] != 3) continue;
541  c0 = energy + ggg[index[q] + p] + P->internal_loop[l1 + j - q - 1];
542  if(c0 <= threshold){
543  ge[cnt] = energy + P->internal_loop[l1 + j - q - 1];
544  (*p_p)[cnt] = p;
545  (*q_p)[cnt++] = q;
546  }
547  }
548  }
549 
550  q = j - 1;
551  if(S[q] == 3)
552  for(p = i + 4;
553  p < j - VRNA_GQUAD_MIN_BOX_SIZE;
554  p++){
555  l1 = p - i - 1;
556  if(l1>MAXLOOP) break;
557  if(S[p] != 3) continue;
558  c0 = energy + ggg[index[q] + p] + P->internal_loop[l1];
559  if(c0 <= threshold){
560  ge[cnt] = energy + P->internal_loop[l1];
561  (*p_p)[cnt] = p;
562  (*q_p)[cnt++] = q;
563  }
564  }
565 
566 
567  (*p_p)[cnt] = -1;
568 
569  return ge;
570 }
571 
572 INLINE PRIVATE
573 int
574 E_GQuad_IntLoop_L(int i,
575  int j,
576  int type,
577  short *S,
578  int **ggg,
579  int maxdist,
580  paramT *P){
581 
582  int energy, ge, dangles, p, q, l1, minq, maxq, c0;
583  short si, sj;
584 
585  dangles = P->model_details.dangles;
586  si = S[i + 1];
587  sj = S[j - 1];
588  energy = 0;
589 
590  if(dangles == 2)
591  energy += P->mismatchI[type][si][sj];
592 
593  if(type > 2)
594  energy += P->TerminalAU;
595 
596  ge = INF;
597 
598  p = i + 1;
599  if(S[p] == 3){
600  if(p < j - VRNA_GQUAD_MIN_BOX_SIZE){
601  minq = j - i + p - MAXLOOP - 2;
602  c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
603  minq = MAX2(c0, minq);
604  c0 = j - 3;
605  maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
606  maxq = MIN2(c0, maxq);
607  for(q = minq; q < maxq; q++){
608  if(S[q] != 3) continue;
609  c0 = energy + ggg[p][q-p] + P->internal_loop[j - q - 1];
610  ge = MIN2(ge, c0);
611  }
612  }
613  }
614 
615  for(p = i + 2;
616  p < j - VRNA_GQUAD_MIN_BOX_SIZE;
617  p++){
618  l1 = p - i - 1;
619  if(l1>MAXLOOP) break;
620  if(S[p] != 3) continue;
621  minq = j - i + p - MAXLOOP - 2;
622  c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
623  minq = MAX2(c0, minq);
624  c0 = j - 1;
625  maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
626  maxq = MIN2(c0, maxq);
627  for(q = minq; q < maxq; q++){
628  if(S[q] != 3) continue;
629  c0 = energy + ggg[p][q - p] + P->internal_loop[l1 + j - q - 1];
630  ge = MIN2(ge, c0);
631  }
632  }
633 
634  q = j - 1;
635  if(S[q] == 3)
636  for(p = i + 4;
637  p < j - VRNA_GQUAD_MIN_BOX_SIZE;
638  p++){
639  l1 = p - i - 1;
640  if(l1>MAXLOOP) break;
641  if(S[p] != 3) continue;
642  c0 = energy + ggg[p][q - p] + P->internal_loop[l1];
643  ge = MIN2(ge, c0);
644  }
645 
646  return ge;
647 }
648 
649 INLINE PRIVATE
650 FLT_OR_DBL
651 exp_E_GQuad_IntLoop(int i,
652  int j,
653  int type,
654  short *S,
655  FLT_OR_DBL *G,
656  int *index,
657  pf_paramT *pf){
658 
659  int k, l, minl, maxl, u, r;
660  FLT_OR_DBL q, qe, *expintern;
661  short si, sj;
662 
663  q = 0;
664  si = S[i + 1];
665  sj = S[j - 1];
666  qe = pf->expmismatchI[type][si][sj];
667  expintern = pf->expinternal;
668 
669  if(type > 2)
670  qe *= pf->expTermAU;
671 
672  k = i + 1;
673  if(S[k] == 3){
674  if(k < j - VRNA_GQUAD_MIN_BOX_SIZE){
675  minl = j - i + k - MAXLOOP - 2;
676  u = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
677  minl = MAX2(u, minl);
678  u = j - 3;
679  maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
680  maxl = MIN2(u, maxl);
681  for(l = minl; l < maxl; l++){
682  if(S[l] != 3) continue;
683  if(G[index[k]-l] == 0.) continue;
684  q += qe * G[index[k]-l] * expintern[j - l - 1];
685  }
686  }
687  }
688 
689 
690  for(k = i + 2;
691  k <= j - VRNA_GQUAD_MIN_BOX_SIZE;
692  k++){
693  u = k - i - 1;
694  if(u > MAXLOOP) break;
695  if(S[k] != 3) continue;
696  minl = j - i + k - MAXLOOP - 2;
697  r = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
698  minl = MAX2(r, minl);
699  maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
700  r = j - 1;
701  maxl = MIN2(r, maxl);
702  for(l = minl; l < maxl; l++){
703  if(S[l] != 3) continue;
704  if(G[index[k]-l] == 0.) continue;
705  q += qe * G[index[k]-l] * expintern[u + j - l - 1];
706  }
707  }
708 
709  l = j - 1;
710  if(S[l] == 3)
711  for(k = i + 4; k < j - VRNA_GQUAD_MIN_BOX_SIZE; k++){
712  u = k - i - 1;
713  if(u>MAXLOOP) break;
714  if(S[k] != 3) continue;
715  if(G[index[k]-l] == 0.) continue;
716  q += qe * G[index[k]-l] * expintern[u];
717  }
718 
719  return q;
720 }
721 
722 #endif
#define MIN2(A, B)
Definition: utils.h:150
void * space(unsigned size)
Allocate space safely.
int dangles
Switch the energy model for dangling end contributions (0, 1, 2, 3)
#define MAXLOOP
Definition: energy_const.h:28
The datastructure that contains temperature scaled energy parameters.
Definition: data_structures.h:180
model_detailsT model_details
Model details to be used in the recursions.
Definition: data_structures.h:218
The datastructure that contains temperature scaled Boltzmann weights of the energy parameters...
Definition: data_structures.h:225
All datastructures and typedefs shared among the Vienna RNA Package can be found here.
int parse_gquad(const char *struc, int *L, int l[3])
this datastructure is used as input parameter in functions of PS_dot.h and others ...
Definition: data_structures.h:94
#define INF
Definition: energy_const.h:16
int dangles
Specifies the dangle model used in any energy evaluation (0,1,2 or 3)
Definition: model.h:209
PRIVATE int backtrack_GQuad_IntLoop_L(int c, int i, int j, int type, short *S, int **ggg, int maxdist, int *p, int *q, paramT *P)
Definition: gquad.h:258
PRIVATE int backtrack_GQuad_IntLoop(int c, int i, int j, int type, short *S, int *ggg, int *index, int *p, int *q, paramT *P)
Definition: gquad.h:160
FLT_OR_DBL * pr
A pointer to the base pair probability matrix.
int * get_gquad_matrix(short *S, paramT *P)
Get a triangular matrix prefilled with minimum free energy contributions of G-quadruplexes.
#define MAX2(A, B)
Definition: utils.h:154