RNAlib-2.4.14
internal.h
Go to the documentation of this file.
1 #ifndef VIENNA_RNA_PACKAGE_LOOPS_INTERNAL_H
2 #define VIENNA_RNA_PACKAGE_LOOPS_INTERNAL_H
3 
4 #include <ViennaRNA/utils/basic.h>
5 #include <ViennaRNA/params/default.h>
6 #include <ViennaRNA/datastructures/basic.h>
7 #include <ViennaRNA/fold_compound.h>
8 #include <ViennaRNA/params/basic.h>
9 #include <ViennaRNA/constraints/hard.h>
10 #include <ViennaRNA/constraints/soft.h>
11 
12 #ifdef VRNA_WARN_DEPRECATED
13 # if defined(DEPRECATED)
14 # undef DEPRECATED
15 # endif
16 # if defined(__clang__)
17 # define DEPRECATED(func, msg) func __attribute__ ((deprecated("", msg)))
18 # elif defined(__GNUC__)
19 # define DEPRECATED(func, msg) func __attribute__ ((deprecated(msg)))
20 # else
21 # define DEPRECATED(func, msg) func
22 # endif
23 #else
24 # define DEPRECATED(func, msg) func
25 #endif
26 
27 #ifdef __GNUC__
28 # define INLINE inline
29 #else
30 # define INLINE
31 #endif
32 
50 int
51 vrna_E_int_loop(vrna_fold_compound_t *fc,
52  int i,
53  int j);
54 
55 
63 int
64 vrna_eval_int_loop(vrna_fold_compound_t *fc,
65  int i,
66  int j,
67  int k,
68  int l);
69 
70 
71 int
72 vrna_E_ext_int_loop(vrna_fold_compound_t *fc,
73  int i,
74  int j,
75  int *ip,
76  int *iq);
77 
78 
79 int
80 vrna_E_stack(vrna_fold_compound_t *fc,
81  int i,
82  int j);
83 
84 
85 /* End basic interface */
95 /* j < i indicates circular folding, i.e. collect contributions for exterior int loops */
96 FLT_OR_DBL
97 vrna_exp_E_int_loop(vrna_fold_compound_t *fc,
98  int i,
99  int j);
100 
101 
102 FLT_OR_DBL
103 vrna_exp_E_interior_loop(vrna_fold_compound_t *fc,
104  int i,
105  int j,
106  int k,
107  int l);
108 
109 
110 /* End partition function interface */
128 int
129 vrna_BT_stack(vrna_fold_compound_t *fc,
130  int *i,
131  int *j,
132  int *en,
133  vrna_bp_stack_t *bp_stack,
134  int *stack_count);
135 
136 
141 int
142 vrna_BT_int_loop(vrna_fold_compound_t *fc,
143  int *i,
144  int *j,
145  int en,
146  vrna_bp_stack_t *bp_stack,
147  int *stack_count);
148 
149 
155 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
156 
162 #ifdef ON_SAME_STRAND
163 #undef ON_SAME_STRAND
164 #endif
165 
166 #define ON_SAME_STRAND(I, J, C) (((I) >= (C)) || ((J) < (C)))
167 
212 PRIVATE INLINE int E_IntLoop(int n1,
213  int n2,
214  int type,
215  int type_2,
216  int si1,
217  int sj1,
218  int sp1,
219  int sq1,
220  vrna_param_t *P);
221 
222 
242 PRIVATE INLINE FLT_OR_DBL exp_E_IntLoop(int u1,
243  int u2,
244  int type,
245  int type2,
246  short si1,
247  short sj1,
248  short sp1,
249  short sq1,
250  vrna_exp_param_t *P);
251 
252 
253 PRIVATE INLINE int E_IntLoop_Co(int type,
254  int type_2,
255  int i,
256  int j,
257  int p,
258  int q,
259  int cutpoint,
260  short si1,
261  short sj1,
262  short sp1,
263  short sq1,
264  int dangles,
265  vrna_param_t *P);
266 
267 
268 /*
269  * ugly but fast interior loop evaluation
270  *
271  * Avoid including this function in your own code. It only serves
272  * as a fast inline block internally re-used throughout the RNAlib. It
273  * evalutes the free energy of interior loops in single sequences or sequence
274  * hybrids. Soft constraints are also applied if available.
275  *
276  * NOTE: do not include into doxygen reference manual!
277  */
278 PRIVATE INLINE int
279 ubf_eval_int_loop(int i,
280  int j,
281  int p,
282  int q,
283  int i1,
284  int j1,
285  int p1,
286  int q1,
287  short si,
288  short sj,
289  short sp,
290  short sq,
291  unsigned char type,
292  unsigned char type_2,
293  int *rtype,
294  int ij,
295  int cp,
296  vrna_param_t *P,
297  vrna_sc_t *sc)
298 {
299  int energy, u1, u2;
300 
301  u1 = p1 - i;
302  u2 = j1 - q;
303 
304  if ((cp < 0) || (ON_SAME_STRAND(i, p, cp) && ON_SAME_STRAND(q, j, cp))) {
305  /* regular interior loop */
306  energy = E_IntLoop(u1, u2, type, type_2, si, sj, sp, sq, P);
307  } else {
308  /* interior loop like cofold structure */
309  short Si, Sj;
310  Si = ON_SAME_STRAND(i, i1, cp) ? si : -1;
311  Sj = ON_SAME_STRAND(j1, j, cp) ? sj : -1;
312  energy = E_IntLoop_Co(rtype[type], rtype[type_2],
313  i, j, p, q,
314  cp,
315  Si, Sj,
316  sp, sq,
317  P->model_details.dangles,
318  P);
319  }
320 
321  /* add soft constraints */
322  if (sc) {
323  if (sc->energy_up)
324  energy += sc->energy_up[i1][u1]
325  + sc->energy_up[q1][u2];
326 
327  if (sc->energy_bp)
328  energy += sc->energy_bp[ij];
329 
330  if (sc->energy_stack)
331  if (u1 + u2 == 0) {
332  int a = sc->energy_stack[i]
333  + sc->energy_stack[p]
334  + sc->energy_stack[q]
335  + sc->energy_stack[j];
336  energy += a;
337  }
338 
339  if (sc->f)
340  energy += sc->f(i, j, p, q, VRNA_DECOMP_PAIR_IL, sc->data);
341  }
342 
343  return energy;
344 }
345 
346 
347 PRIVATE INLINE int
348 ubf_eval_int_loop2(int i,
349  int j,
350  int p,
351  int q,
352  int i1,
353  int j1,
354  int p1,
355  int q1,
356  short si,
357  short sj,
358  short sp,
359  short sq,
360  unsigned char type,
361  unsigned char type_2,
362  int *rtype,
363  int ij,
364  unsigned int *sn,
365  unsigned int *ss,
366  vrna_param_t *P,
367  vrna_sc_t *sc)
368 {
369  int energy, u1, u2;
370 
371  u1 = p1 - i;
372  u2 = j1 - q;
373 
374  if ((sn[i] == sn[p]) && (sn[q] == sn[j])) {
375  /* regular interior loop */
376  energy = E_IntLoop(u1, u2, type, type_2, si, sj, sp, sq, P);
377  } else {
378  /* interior loop like cofold structure */
379  short Si, Sj;
380  Si = (sn[i1] == sn[i]) ? si : -1;
381  Sj = (sn[j] == sn[j1]) ? sj : -1;
382  energy = E_IntLoop_Co(rtype[type], rtype[type_2],
383  i, j, p, q,
384  ss[1],
385  Si, Sj,
386  sp, sq,
387  P->model_details.dangles,
388  P);
389  }
390 
391  /* add soft constraints */
392  if (sc) {
393  if (sc->energy_up)
394  energy += sc->energy_up[i1][u1]
395  + sc->energy_up[q1][u2];
396 
397  if (sc->energy_bp)
398  energy += sc->energy_bp[ij];
399 
400  if (sc->energy_stack)
401  if (u1 + u2 == 0) {
402  int a = sc->energy_stack[i]
403  + sc->energy_stack[p]
404  + sc->energy_stack[q]
405  + sc->energy_stack[j];
406  energy += a;
407  }
408 
409  if (sc->f)
410  energy += sc->f(i, j, p, q, VRNA_DECOMP_PAIR_IL, sc->data);
411  }
412 
413  return energy;
414 }
415 
416 
417 /*
418  * ugly but fast exterior interior loop evaluation
419  *
420  * Avoid including this function in your own code. It only serves
421  * as a fast inline block internally re-used throughout the RNAlib. It
422  * evalutes the free energy of interior loops in single sequences or sequence
423  * hybrids. Soft constraints are also applied if available.
424  *
425  * NOTE: do not include into doxygen reference manual!
426  */
427 PRIVATE INLINE int
428 ubf_eval_ext_int_loop(int i,
429  int j,
430  int p,
431  int q,
432  int i1,
433  int j1,
434  int p1,
435  int q1,
436  short si,
437  short sj,
438  short sp,
439  short sq,
440  unsigned char type,
441  unsigned char type_2,
442  int length,
443  vrna_param_t *P,
444  vrna_sc_t *sc)
445 {
446  int energy, u1, u2, u3;
447 
448  u1 = i1;
449  u2 = p1 - j;
450  u3 = length - q;
451 
452  energy = E_IntLoop(u2, u1 + u3, type, type_2, si, sj, sp, sq, P);
453 
454  /* add soft constraints */
455  if (sc) {
456  if (sc->energy_up) {
457  energy += sc->energy_up[j1][u2]
458  + ((u3 > 0) ? sc->energy_up[q1][u3] : 0)
459  + ((u1 > 0) ? sc->energy_up[1][u1] : 0);
460  }
461 
462  if (sc->energy_stack)
463  if (u1 + u2 + u3 == 0)
464  energy += sc->energy_stack[i]
465  + sc->energy_stack[p]
466  + sc->energy_stack[q]
467  + sc->energy_stack[j];
468 
469  if (sc->f)
470  energy += sc->f(i, j, p, q, VRNA_DECOMP_PAIR_IL, sc->data);
471  }
472 
473  return energy;
474 }
475 
476 
477 PRIVATE INLINE int
478 E_IntLoop(int n1,
479  int n2,
480  int type,
481  int type_2,
482  int si1,
483  int sj1,
484  int sp1,
485  int sq1,
486  vrna_param_t *P)
487 {
488  /* compute energy of degree 2 loop (stack bulge or interior) */
489  int nl, ns, u, energy;
490 
491  energy = INF;
492 
493  if (n1 > n2) {
494  nl = n1;
495  ns = n2;
496  } else {
497  nl = n2;
498  ns = n1;
499  }
500 
501  if (nl == 0)
502  return P->stack[type][type_2]; /* stack */
503 
504  if (ns == 0) {
505  /* bulge */
506  energy = (nl <= MAXLOOP) ? P->bulge[nl] :
507  (P->bulge[30] + (int)(P->lxc * log(nl / 30.)));
508  if (nl == 1) {
509  energy += P->stack[type][type_2];
510  } else {
511  if (type > 2)
512  energy += P->TerminalAU;
513 
514  if (type_2 > 2)
515  energy += P->TerminalAU;
516  }
517 
518  return energy;
519  } else {
520  /* interior loop */
521  if (ns == 1) {
522  if (nl == 1) /* 1x1 loop */
523  return P->int11[type][type_2][si1][sj1];
524 
525  if (nl == 2) {
526  /* 2x1 loop */
527  if (n1 == 1)
528  energy = P->int21[type][type_2][si1][sq1][sj1];
529  else
530  energy = P->int21[type_2][type][sq1][si1][sp1];
531 
532  return energy;
533  } else {
534  /* 1xn loop */
535  energy =
536  (nl + 1 <=
537  MAXLOOP) ? (P->internal_loop[nl + 1]) : (P->internal_loop[30] +
538  (int)(P->lxc * log((nl + 1) / 30.)));
539  energy += MIN2(MAX_NINIO, (nl - ns) * P->ninio[2]);
540  energy += P->mismatch1nI[type][si1][sj1] + P->mismatch1nI[type_2][sq1][sp1];
541  return energy;
542  }
543  } else if (ns == 2) {
544  if (nl == 2) {
545  /* 2x2 loop */
546  return P->int22[type][type_2][si1][sp1][sq1][sj1];
547  } else if (nl == 3) {
548  /* 2x3 loop */
549  energy = P->internal_loop[5] + P->ninio[2];
550  energy += P->mismatch23I[type][si1][sj1] + P->mismatch23I[type_2][sq1][sp1];
551  return energy;
552  }
553  }
554 
555  {
556  /* generic interior loop (no else here!)*/
557  u = nl + ns;
558  energy =
559  (u <=
560  MAXLOOP) ? (P->internal_loop[u]) : (P->internal_loop[30] + (int)(P->lxc * log((u) / 30.)));
561 
562  energy += MIN2(MAX_NINIO, (nl - ns) * P->ninio[2]);
563 
564  energy += P->mismatchI[type][si1][sj1] + P->mismatchI[type_2][sq1][sp1];
565  }
566  }
567 
568  return energy;
569 }
570 
571 
572 PRIVATE INLINE FLT_OR_DBL
573 exp_E_IntLoop(int u1,
574  int u2,
575  int type,
576  int type2,
577  short si1,
578  short sj1,
579  short sp1,
580  short sq1,
581  vrna_exp_param_t *P)
582 {
583  int ul, us, no_close = 0;
584  double z = 0.;
585  int noGUclosure = P->model_details.noGUclosure;
586 
587  if ((noGUclosure) && ((type2 == 3) || (type2 == 4) || (type == 3) || (type == 4)))
588  no_close = 1;
589 
590  if (u1 > u2) {
591  ul = u1;
592  us = u2;
593  } else {
594  ul = u2;
595  us = u1;
596  }
597 
598  if (ul == 0) {
599  /* stack */
600  z = P->expstack[type][type2];
601  } else if (!no_close) {
602  if (us == 0) {
603  /* bulge */
604  z = P->expbulge[ul];
605  if (ul == 1) {
606  z *= P->expstack[type][type2];
607  } else {
608  if (type > 2)
609  z *= P->expTermAU;
610 
611  if (type2 > 2)
612  z *= P->expTermAU;
613  }
614 
615  return (FLT_OR_DBL)z;
616  } else if (us == 1) {
617  if (ul == 1) /* 1x1 loop */
618  return (FLT_OR_DBL)(P->expint11[type][type2][si1][sj1]);
619 
620  if (ul == 2) {
621  /* 2x1 loop */
622  if (u1 == 1)
623  return (FLT_OR_DBL)(P->expint21[type][type2][si1][sq1][sj1]);
624  else
625  return (FLT_OR_DBL)(P->expint21[type2][type][sq1][si1][sp1]);
626  } else {
627  /* 1xn loop */
628  z = P->expinternal[ul + us] * P->expmismatch1nI[type][si1][sj1] *
629  P->expmismatch1nI[type2][sq1][sp1];
630  return (FLT_OR_DBL)(z * P->expninio[2][ul - us]);
631  }
632  } else if (us == 2) {
633  if (ul == 2) {
634  /* 2x2 loop */
635  return (FLT_OR_DBL)(P->expint22[type][type2][si1][sp1][sq1][sj1]);
636  } else if (ul == 3) {
637  /* 2x3 loop */
638  z = P->expinternal[5] * P->expmismatch23I[type][si1][sj1] *
639  P->expmismatch23I[type2][sq1][sp1];
640  return (FLT_OR_DBL)(z * P->expninio[2][1]);
641  }
642  }
643 
644  /* generic interior loop (no else here!)*/
645  z = P->expinternal[ul + us] * P->expmismatchI[type][si1][sj1] *
646  P->expmismatchI[type2][sq1][sp1];
647  return (FLT_OR_DBL)(z * P->expninio[2][ul - us]);
648  }
649 
650  return (FLT_OR_DBL)z;
651 }
652 
653 
654 PRIVATE INLINE int
655 E_IntLoop_Co(int type,
656  int type_2,
657  int i,
658  int j,
659  int p,
660  int q,
661  int cutpoint,
662  short si1,
663  short sj1,
664  short sp1,
665  short sq1,
666  int dangles,
667  vrna_param_t *P)
668 {
669  int energy, ci, cj, cp, cq, d3, d5, d5_2, d3_2, tmm, tmm_2;
670 
671  energy = 0;
672  if (type > 2)
673  energy += P->TerminalAU;
674 
675  if (type_2 > 2)
676  energy += P->TerminalAU;
677 
678  if (!dangles)
679  return energy;
680 
681  ci = ON_SAME_STRAND(i, i + 1, cutpoint);
682  cj = ON_SAME_STRAND(j - 1, j, cutpoint);
683  cp = ON_SAME_STRAND(p - 1, p, cutpoint);
684  cq = ON_SAME_STRAND(q, q + 1, cutpoint);
685 
686  d3 = ci ? P->dangle3[type][si1] : 0;
687  d5 = cj ? P->dangle5[type][sj1] : 0;
688  d5_2 = cp ? P->dangle5[type_2][sp1] : 0;
689  d3_2 = cq ? P->dangle3[type_2][sq1] : 0;
690 
691  tmm = (cj && ci) ? P->mismatchExt[type][sj1][si1] : d5 + d3;
692  tmm_2 = (cp && cq) ? P->mismatchExt[type_2][sp1][sq1] : d5_2 + d3_2;
693 
694  if (dangles == 2)
695  return energy + tmm + tmm_2;
696 
697  /* now we may have non-double dangles only */
698  if (p - i > 2) {
699  if (j - q > 2)
700  energy += tmm + tmm_2;
701  else if (j - q == 2)
702  energy += (cj && cq) ? MIN2(tmm + d5_2, tmm_2 + d3) : tmm + tmm_2;
703  else
704  energy += d3 + d5_2;
705  } else if (p - i == 2) {
706  if (j - q > 2)
707  energy += (ci && cp) ? MIN2(tmm + d3_2, tmm_2 + d5) : tmm + tmm_2;
708  else if (j - q == 2)
709  energy += MIN2(tmm, MIN2(tmm_2, MIN2(d5 + d5_2, d3 + d3_2)));
710  else
711  energy += MIN2(d3, d5_2);
712  } else {
713  if (j - q > 2)
714  energy += d5 + d3_2;
715  else if (j - q == 2)
716  energy += MIN2(d5, d3_2);
717  }
718 
719  return energy;
720 }
721 
722 
727 #endif
728 
729 #endif
soft.h
Functions and data structures for secondary structure soft constraints.
vrna_eval_int_loop
int vrna_eval_int_loop(vrna_fold_compound_t *fc, int i, int j, int k, int l)
Evaluate the free energy contribution of an interior loop with delimiting base pairs and ...
vrna_param_s::model_details
vrna_md_t model_details
Model details to be used in the recursions.
Definition: basic.h:96
vrna_exp_param_s::model_details
vrna_md_t model_details
Model details to be used in the recursions.
Definition: basic.h:154
FLT_OR_DBL
double FLT_OR_DBL
Typename for floating point number in partition function computations.
Definition: basic.h:43
vrna_fc_s
The most basic data structure required by many functions throughout the RNAlib.
Definition: fold_compound.h:132
vrna_param_s
The datastructure that contains temperature scaled energy parameters.
Definition: basic.h:57
vrna_sc_s::energy_stack
int * energy_stack
Pseudo Energy contribution per base pair involved in a stack.
Definition: soft.h:203
MIN2
#define MIN2(A, B)
Get the minimum of two comparable values.
Definition: basic.h:111
MAXLOOP
#define MAXLOOP
Definition: constants.h:29
vrna_sc_s::f
vrna_callback_sc_energy * f
A function pointer used for pseudo energy contribution in MFE calculations.
Definition: soft.h:207
INF
#define INF
Definition: constants.h:17
basic.h
Various data structures and pre-processor macros.
vrna_sc_s
The soft constraints data structure.
Definition: soft.h:171
vrna_exp_param_s
The data structure that contains temperature scaled Boltzmann weights of the energy parameters...
Definition: basic.h:103
hard.h
Functions and data structures for handling of secondary structure hard constraints.
vrna_sc_s::energy_up
int ** energy_up
Energy contribution for stretches of unpaired nucleotides.
Definition: soft.h:177
VRNA_DECOMP_PAIR_IL
#define VRNA_DECOMP_PAIR_IL
Indicator for interior loop decomposition step.
Definition: basic.h:144
vrna_BT_int_loop
int vrna_BT_int_loop(vrna_fold_compound_t *fc, int *i, int *j, int en, vrna_bp_stack_t *bp_stack, int *stack_count)
Backtrack an interior loop closed by .
vrna_md_s::dangles
int dangles
Specifies the dangle model used in any energy evaluation (0,1,2 or 3)
Definition: model.h:184
vrna_bp_stack_s
Base pair stack element.
Definition: basic.h:143
basic.h
Functions to deal with sets of energy parameters.
vrna_sc_s::energy_bp
int * energy_bp
Energy contribution for base pairs.
Definition: soft.h:188
vrna_BT_stack
int vrna_BT_stack(vrna_fold_compound_t *fc, int *i, int *j, int *en, vrna_bp_stack_t *bp_stack, int *stack_count)
Backtrack a stacked pair closed by .
fold_compound.h
The Basic Fold Compound API.
basic.h
General utility- and helper-functions used throughout the ViennaRNA Package.
vrna_md_s::noGUclosure
int noGUclosure
Do not allow loops to be closed by GU pair.
Definition: model.h:211
dangles
int dangles
Switch the energy model for dangling end contributions (0, 1, 2, 3)
exp_E_IntLoop
PRIVATE FLT_OR_DBL exp_E_IntLoop(int u1, int u2, int type, int type2, short si1, short sj1, short sp1, short sq1, vrna_exp_param_t *P)
Definition: internal.h:573
E_IntLoop
PRIVATE int E_IntLoop(int n1, int n2, int type, int type_2, int si1, int sj1, int sp1, int sq1, vrna_param_t *P)
Definition: internal.h:478
vrna_sc_s::data
void * data
A pointer to the data object provided for for pseudo energy contribution functions of the generic sof...
Definition: soft.h:224