RNAlib-2.2.0-RC2
interior_loops.h
Go to the documentation of this file.
1 #ifndef VIENNA_RNA_PACKAGE_INTERIOR_LOOPS_H
2 #define VIENNA_RNA_PACKAGE_INTERIOR_LOOPS_H
3 
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <math.h>
7 #include <ctype.h>
8 #include <string.h>
9 #include <ViennaRNA/fold_vars.h>
10 #include <ViennaRNA/energy_par.h>
11 #include <ViennaRNA/params.h>
12 #include <ViennaRNA/constraints.h>
13 #include <ViennaRNA/gquad.h>
14 
15 #ifdef __GNUC__
16 # define INLINE inline
17 #else
18 # define INLINE
19 #endif
20 
74 INLINE PRIVATE int E_IntLoop(int n1,
75  int n2,
76  int type,
77  int type_2,
78  int si1,
79  int sj1,
80  int sp1,
81  int sq1,
82  vrna_param_t *P);
83 
103 INLINE PRIVATE double exp_E_IntLoop(int u1,
104  int u2,
105  int type,
106  int type2,
107  short si1,
108  short sj1,
109  short sp1,
110  short sq1,
111  vrna_exp_param_t *P);
112 
113 
114 INLINE PRIVATE int E_IntLoop_Co(int type,
115  int type_2,
116  int i,
117  int j,
118  int p,
119  int q,
120  int cutpoint,
121  short si1,
122  short sj1,
123  short sp1,
124  short sq1,
125  int dangles,
126  vrna_param_t *P);
127 
128 
132 INLINE PRIVATE int E_stack(int i, int j, vrna_fold_compound *vc);
133 
134 /*
135 #################################
136 # BEGIN OF FUNCTION DEFINITIONS #
137 #################################
138 */
139 
140 /*
141  * ugly but fast interior loop evaluation
142  *
143  * This function may be included in your own code, but actually only serves
144  * as a fast inline block internally re-used throughout the RNAlib. It
145  * evalutes the free energy of interior loops in single sequences or sequence
146  * hybrids. Soft constraints are also applied if available.
147  *
148  * NOTE: do not include into doxygen reference manual!
149  */
150 INLINE PRIVATE int
151 ubf_eval_int_loop( int i,
152  int j,
153  int p,
154  int q,
155  int u1,
156  int u2,
157  short si,
158  short sj,
159  short sp,
160  short sq,
161  unsigned char type,
162  unsigned char type_2,
163  int *rtype,
164  int ij,
165  int cp,
166  vrna_param_t *P,
167  vrna_sc_t *sc){
168 
169  int energy;
170 
171  if((cp < 0) || ( ((i >= cp) || (p < cp)) && ((q >= cp) || (j < cp)))){ /* regular interior loop */
172  energy = E_IntLoop(u1, u2, type, type_2, si, sj, sp, sq, P);
173  } else { /* interior loop like cofold structure */
174  short Si, Sj;
175  Si = ((i >= cp) || ((i + 1) < cp)) ? si : -1;
176  Sj = (((j - 1) >= cp) || (j < cp)) ? sj : -1;
177  energy = E_IntLoop_Co(rtype[type], rtype[type_2],
178  i, j, p, q,
179  cp,
180  Si, Sj,
181  sp, sq,
183  P);
184  }
185 
186  /* add soft constraints */
187  if(sc){
188  if(sc->free_energies)
189  energy += sc->free_energies[i+1][u1]
190  + sc->free_energies[q+1][u2];
191 
192  if(sc->en_basepair)
193  energy += sc->en_basepair[ij];
194 
195  if(sc->en_stack)
196  if((p==i+1) && (q == j-1))
197  energy += sc->en_stack[i]
198  + sc->en_stack[p]
199  + sc->en_stack[q]
200  + sc->en_stack[j];
201 
202  if(sc->f)
203  energy += sc->f(i, j, p, q, VRNA_DECOMP_PAIR_IL, sc->data);
204  }
205 
206  return energy;
207 
208 }
209 
210 /*
211  * ugly but fast exterior interior loop evaluation
212  *
213  * This function may be included in your own code, but actually only serves
214  * as a fast inline block internally re-used throughout the RNAlib. It
215  * evalutes the free energy of interior loops in single sequences or sequence
216  * hybrids. Soft constraints are also applied if available.
217  *
218  * NOTE: do not include into doxygen reference manual!
219  */
220 INLINE PRIVATE int
221 ubf_eval_ext_int_loop(int i,
222  int j,
223  int p,
224  int q,
225  int u1,
226  int u2,
227  short si,
228  short sj,
229  short sp,
230  short sq,
231  unsigned char type,
232  unsigned char type_2,
233  int length,
234  vrna_param_t *P,
235  vrna_sc_t *sc){
236 
237  int energy;
238 
239  energy = E_IntLoop(u1, u2, type, type_2, si, sj, sp, sq, P);
240 
241  /* add soft constraints */
242  if(sc){
243  if(sc->free_energies)
244  energy += sc->free_energies[j+1][p-j-1]
245  + sc->free_energies[q+1][length-q]
246  + sc->free_energies[1][i-1];
247 
248  if(sc->en_stack)
249  if((p==i+1) && (q == j-1))
250  energy += sc->en_stack[i]
251  + sc->en_stack[p]
252  + sc->en_stack[q]
253  + sc->en_stack[j];
254 
255  if(sc->f)
256  energy += sc->f(i, j, p, q, VRNA_DECOMP_PAIR_IL, sc->data);
257  }
258 
259  return energy;
260 
261 }
262 
263 INLINE PRIVATE int
264 E_int_loop( int i,
265  int j,
266  vrna_fold_compound *vc){
267 
268  int q, p, j_q, p_i, pq, *c_pq, max_q, max_p, tmp, *rtype, noGUclosure, no_close, energy;
269  short *S_p1, *S_q1;
270  char *ptype_pq;
271  unsigned char type, type_2;
272  char *hc_pq;
273  int cp = vc->cutpoint;
274  char *ptype = vc->ptype;
275  short *S = vc->sequence_encoding;
276  short S_i1 = S[i+1];
277  short S_j1 = S[j-1];
278  int *indx = vc->jindx;
279  char *hc = vc->hc->matrix;
280  int *hc_up = vc->hc->up_int;
281  vrna_sc_t *sc = vc->sc;
282  vrna_param_t *P = vc->params;
283  int ij = indx[j] + i;
284  int hc_decompose = hc[ij];
285  int e = INF;
286  int *c = vc->matrices->c;
287  int *ggg = vc->matrices->ggg;
288  vrna_md_t *md = &(P->model_details);
289  int with_gquad = md->gquad;
290  int turn = md->min_loop_size;
291 
292  /* CONSTRAINED INTERIOR LOOP start */
293  if(hc_decompose & VRNA_CONSTRAINT_CONTEXT_INT_LOOP){
294 
295  type = (unsigned char)ptype[ij];
296  rtype = &(md->rtype[0]);
297  noGUclosure = md->noGUclosure;
298  no_close = (((type==3)||(type==4))&&noGUclosure);
299  max_q = i+turn+2;
300  max_q = MAX2(max_q, j - MAXLOOP - 1);
301  for(q = j - 1; q >= max_q; q--){
302  j_q = j - q - 1;
303 
304  if(hc_up[q+1] < j_q) break;
305 
306  pq = indx[q] + i + 1;
307  p_i = 0;
308  max_p = i + 1;
309  tmp = i + 1 + MAXLOOP - j_q;
310  max_p = MAX2(max_p, tmp);
311  tmp = q - turn;
312  max_p = MIN2(max_p, tmp);
313  tmp = i + 1 + hc_up[i + 1];
314  max_p = MIN2(max_p, tmp);
315  hc_pq = hc + pq;
316  c_pq = c + pq;
317  ptype_pq = ptype + pq;
318 
319  S_p1 = S + i;
320  S_q1 = S + q + 1;
321  for(p = i+1; p <= max_p; p++){
322 
323  /* discard this configuration if (p,q) is not allowed to be enclosed pair of an interior loop */
325 
326  if(*c_pq != INF){
327  type_2 = rtype[(unsigned char)*ptype_pq];
328 
329  if (noGUclosure)
330  if (no_close||(type_2==3)||(type_2==4))
331  if ((p>i+1)||(q<j-1)) continue; /* continue unless stack */
332 
333  energy = ubf_eval_int_loop( i, j, p, q,
334  p_i, j_q,
335  S_i1, S_j1, *S_p1, *S_q1,
336  type, type_2, rtype,
337  ij, cp,
338  P, sc);
339  energy += *c_pq;
340  e = MIN2(e, energy);
341  }
342 
343  }
344  hc_pq++; /* get hc[pq + 1] */
345  c_pq++; /* get c[pq + 1] */
346  p_i++; /* increase unpaired region [i+1...p-1] */
347  ptype_pq++; /* get ptype[pq + 1] */
348  S_p1++;
349  pq++;
350  } /* end q-loop */
351  } /* end p-loop */
352 
353  if(with_gquad){
354  /* include all cases where a g-quadruplex may be enclosed by base pair (i,j) */
355  if ((!no_close) && ((cp < 0) || ((i >= cp) || (j < cp)))) {
356  energy = E_GQuad_IntLoop(i, j, type, S, ggg, indx, P);
357  e = MIN2(e, energy);
358  }
359  }
360 
361  }
362  return e;
363 }
364 
365 INLINE PRIVATE int
366 vrna_E_ext_int_loop(vrna_fold_compound *vc,
367  int i,
368  int j,
369  int *ip,
370  int *iq){
371 
372  int ij, q, p, e, u1, u2, qmin, energy, *rtype, length, *indx, *hc_up, *c, turn;
373  unsigned char type, type_2;
374  vrna_md_t *md;
375  char *ptype, *hc;
376  vrna_param_t *P;
377  short *S;
378  vrna_sc_t *sc;
379 
380  length = vc->length;
381  indx = vc->jindx;
382  ptype = vc->ptype;
383  c = vc->matrices->c;
384  hc = vc->hc->matrix;
385  hc_up = vc->hc->up_int;
386  P = vc->params;
387  md = &(P->model_details);
388  turn = md->min_loop_size;
389  S = vc->sequence_encoding;
390  sc = vc->sc;
391 
392  ij = indx[j] + i;
393  rtype = &(md->rtype[0]);
394  type = rtype[(unsigned char)ptype[ij]];
395  e = INF;
396 
397  /* CONSTRAINED INTERIOR LOOP start */
398  if(hc[ij] & VRNA_CONSTRAINT_CONTEXT_INT_LOOP){
399 
400  for (p = j+1; p < length ; p++) {
401  u1 = p-j-1;
402  if (u1+i-1>MAXLOOP) break;
403  if (hc_up[j+1] < u1) break;
404 
405  qmin = u1+i-1+length-MAXLOOP;
406  if(qmin < p + turn + 1)
407  qmin = p+turn+1;
408  for (q = length; q >= qmin; q--) {
409  u2 = i-1 + length-q;
410  if(hc_up[q+1] < u2) break;
411  if(hc[indx[q]+p] & VRNA_CONSTRAINT_CONTEXT_INT_LOOP){
412  type_2 = rtype[(unsigned char)ptype[indx[q]+p]];
413  if (u1+u2>MAXLOOP) continue;
414 
415  energy = ubf_eval_ext_int_loop( i, j, p, q,
416  u1, u2,
417  S[j+1], S[i-1], S[p-1], S[q+1],
418  type, type_2,
419  length,
420  P, sc);
421  energy += c[indx[q]+p];
422 
423  if (energy < e){
424  e = energy;
425  if((ip != NULL) && (iq != NULL)){
426  *ip = p;
427  *iq = q;
428  }
429  }
430  }
431  }
432  }
433  }
434 
435  return e;
436 }
437 
438 
439 INLINE PRIVATE int
440 E_stack(int i,
441  int j,
442  vrna_fold_compound *vc){
443 
444  int e, ij, pq, p, q;
445  unsigned char type, type_2;
446 
447  int cp = vc->cutpoint;
448  short *S = vc->sequence_encoding;
449  char *ptype = vc->ptype;
450  vrna_param_t *P = vc->params;
451  vrna_md_t *md = &(P->model_details);
452  int *rtype = &(md->rtype[0]);
453  int *indx = vc->jindx;
454  char *hard_constraints = vc->hc->matrix;
455  vrna_sc_t *sc = vc->sc;
456 
457  e = INF;
458  p = i + 1;
459  q = j - 1;
460  ij = indx[j] + i;
461  pq = indx[q] + p;
462  type = (unsigned char)ptype[ij];
463  type_2 = rtype[(unsigned char)ptype[pq]];
464 
465  if((hard_constraints[pq] & VRNA_CONSTRAINT_CONTEXT_INT_LOOP_ENC) && (hard_constraints[ij] & VRNA_CONSTRAINT_CONTEXT_INT_LOOP)){
466  if ((cp < 0) || (((i >= cp) || (p < cp)) && ((q >= cp) || (j < cp)))){ /* regular stack */
467  e = P->stack[type][type_2];
468  } else { /* stack like cofold structure */
469  short si, sj;
470  si = ((i >= cp) || ((i + 1) < cp)) ? S[i+1] : -1;
471  sj = (((j - 1) >= cp) || (j < cp)) ? S[j-1] : -1;
472  e = E_IntLoop_Co(rtype[type], rtype[type_2],
473  i, j, p, q,
474  cp,
475  si, sj,
476  S[p-1], S[q+1],
477  md->dangles,
478  P);
479  }
480 
481  /* add soft constraints */
482  if(sc){
483  if(sc->en_basepair)
484  e += sc->en_basepair[ij];
485 
486  if(sc->en_stack)
487  if((p==i+1) && (q == j-1))
488  e += sc->en_stack[i]
489  + sc->en_stack[p]
490  + sc->en_stack[q]
491  + sc->en_stack[j];
492 
493  if(sc->f)
494  e += sc->f(i, j, p, q, VRNA_DECOMP_PAIR_IL, sc->data);
495  }
496  }
497 
498  return e;
499 }
500 
501 INLINE PRIVATE int
502 E_IntLoop(int n1,
503  int n2,
504  int type,
505  int type_2,
506  int si1,
507  int sj1,
508  int sp1,
509  int sq1,
510  vrna_param_t *P){
511 
512  /* compute energy of degree 2 loop (stack bulge or interior) */
513  int nl, ns, u, energy;
514  energy = INF;
515 
516  if (n1>n2) { nl=n1; ns=n2;}
517  else {nl=n2; ns=n1;}
518 
519  if (nl == 0)
520  return P->stack[type][type_2]; /* stack */
521 
522  if (ns==0) { /* bulge */
523  energy = (nl<=MAXLOOP)?P->bulge[nl]:
524  (P->bulge[30]+(int)(P->lxc*log(nl/30.)));
525  if (nl==1) energy += P->stack[type][type_2];
526  else {
527  if (type>2) energy += P->TerminalAU;
528  if (type_2>2) energy += P->TerminalAU;
529  }
530  return energy;
531  }
532  else { /* interior loop */
533  if (ns==1) {
534  if (nl==1) /* 1x1 loop */
535  return P->int11[type][type_2][si1][sj1];
536  if (nl==2) { /* 2x1 loop */
537  if (n1==1)
538  energy = P->int21[type][type_2][si1][sq1][sj1];
539  else
540  energy = P->int21[type_2][type][sq1][si1][sp1];
541  return energy;
542  }
543  else { /* 1xn loop */
544  energy = (nl+1<=MAXLOOP)?(P->internal_loop[nl+1]) : (P->internal_loop[30]+(int)(P->lxc*log((nl+1)/30.)));
545  energy += MIN2(MAX_NINIO, (nl-ns)*P->ninio[2]);
546  energy += P->mismatch1nI[type][si1][sj1] + P->mismatch1nI[type_2][sq1][sp1];
547  return energy;
548  }
549  }
550  else if (ns==2) {
551  if(nl==2) { /* 2x2 loop */
552  return P->int22[type][type_2][si1][sp1][sq1][sj1];}
553  else if (nl==3){ /* 2x3 loop */
554  energy = P->internal_loop[5]+P->ninio[2];
555  energy += P->mismatch23I[type][si1][sj1] + P->mismatch23I[type_2][sq1][sp1];
556  return energy;
557  }
558 
559  }
560  { /* generic interior loop (no else here!)*/
561  u = nl + ns;
562  energy = (u <= MAXLOOP) ? (P->internal_loop[u]) : (P->internal_loop[30]+(int)(P->lxc*log((u)/30.)));
563 
564  energy += MIN2(MAX_NINIO, (nl-ns)*P->ninio[2]);
565 
566  energy += P->mismatchI[type][si1][sj1] + P->mismatchI[type_2][sq1][sp1];
567  }
568  }
569  return energy;
570 }
571 
572 INLINE PRIVATE double exp_E_IntLoop(int u1, int u2, int type, int type2, short si1, short sj1, short sp1, short sq1, vrna_exp_param_t *P){
573  int ul, us, no_close = 0;
574  double z = 0.;
575 
576  if ((no_closingGU) && ((type2==3)||(type2==4)||(type==3)||(type==4)))
577  no_close = 1;
578 
579  if (u1>u2) { ul=u1; us=u2;}
580  else {ul=u2; us=u1;}
581 
582  if (ul==0) /* stack */
583  z = P->expstack[type][type2];
584  else if(!no_close){
585  if (us==0) { /* bulge */
586  z = P->expbulge[ul];
587  if (ul==1) z *= P->expstack[type][type2];
588  else {
589  if (type>2) z *= P->expTermAU;
590  if (type2>2) z *= P->expTermAU;
591  }
592  return z;
593  }
594  else if (us==1) {
595  if (ul==1){ /* 1x1 loop */
596  return P->expint11[type][type2][si1][sj1];
597  }
598  if (ul==2) { /* 2x1 loop */
599  if (u1==1)
600  return P->expint21[type][type2][si1][sq1][sj1];
601  else
602  return P->expint21[type2][type][sq1][si1][sp1];
603  }
604  else { /* 1xn loop */
605  z = P->expinternal[ul+us] * P->expmismatch1nI[type][si1][sj1] * P->expmismatch1nI[type2][sq1][sp1];
606  return z * P->expninio[2][ul-us];
607  }
608  }
609  else if (us==2) {
610  if(ul==2) /* 2x2 loop */
611  return P->expint22[type][type2][si1][sp1][sq1][sj1];
612  else if(ul==3){ /* 2x3 loop */
613  z = P->expinternal[5]*P->expmismatch23I[type][si1][sj1]*P->expmismatch23I[type2][sq1][sp1];
614  return z * P->expninio[2][1];
615  }
616  }
617  /* generic interior loop (no else here!)*/
618  z = P->expinternal[ul+us] * P->expmismatchI[type][si1][sj1] * P->expmismatchI[type2][sq1][sp1];
619  return z * P->expninio[2][ul-us];
620 
621  }
622  return z;
623 }
624 
625 INLINE PRIVATE int
626 E_IntLoop_Co( int type,
627  int type_2,
628  int i,
629  int j,
630  int p,
631  int q,
632  int cutpoint,
633  short si1,
634  short sj1,
635  short sp1,
636  short sq1,
637  int dangles,
638  vrna_param_t *P){
639 
640  int energy, ci, cj, cp, cq, d3, d5, d5_2, d3_2, tmm, tmm_2;
641 
642  energy = 0;
643  if(type > 2) energy += P->TerminalAU;
644  if(type_2 > 2) energy += P->TerminalAU;
645 
646  if(!dangles) return energy;
647 
648  ci = (i>=cutpoint)||((i+1)<cutpoint);
649  cj = ((j-1)>=cutpoint)||(j<cutpoint);
650  cp = ((p-1)>=cutpoint)||(p<cutpoint);
651  cq = (q>=cutpoint)||((q+1)<cutpoint);
652 
653  d3 = ci ? P->dangle3[type][si1] : 0;
654  d5 = cj ? P->dangle5[type][sj1] : 0;
655  d5_2 = cp ? P->dangle5[type_2][sp1] : 0;
656  d3_2 = cq ? P->dangle3[type_2][sq1] : 0;
657 
658  tmm = (cj && ci) ? P->mismatchExt[type][sj1][si1] : d5 + d3;
659  tmm_2 = (cp && cq) ? P->mismatchExt[type_2][sp1][sq1] : d5_2 + d3_2;
660 
661  if(dangles == 2) return energy + tmm + tmm_2;
662 
663  /* now we may have non-double dangles only */
664  if(i+2 < p){
665  if(q+2 < j){ energy += tmm + tmm_2;}
666  else if(q+2 == j){ energy += (cj && cq) ? MIN2(tmm + d5_2, tmm_2 + d3) : tmm + tmm_2;}
667  else energy += d3 + d5_2;
668  }
669  else if(i+2 == p){
670  if(q+2 < j){ energy += (ci && cp) ? MIN2(tmm + d3_2, tmm_2 + d5) : tmm + tmm_2;}
671  else if(q+2 == j){
672  energy += MIN2(tmm, MIN2(tmm_2, MIN2(d5 + d5_2, d3 + d3_2)));
673  }
674  else energy += MIN2(d3, d5_2);
675  }
676  else{
677  if(q+2 < j){ energy += d5 + d3_2;}
678  else if(q+2 == j){ energy += MIN2(d5, d3_2);}
679  }
680  return energy;
681 }
682 
688 #endif
int * ggg
Energies of g-quadruplexes.
Definition: data_structures.h:429
int * c
Energy array, given that i-j pair.
Definition: data_structures.h:422
struct vrna_hc_t * hc
The hard constraints data structure used for structure prediction.
Definition: data_structures.h:707
int noGUclosure
Do not allow loops to be closed by GU pair.
Definition: model.h:181
int cutpoint
The position of the (cofold) cutpoint within the provided sequence. If there is no cutpoint...
Definition: data_structures.h:703
#define VRNA_CONSTRAINT_CONTEXT_INT_LOOP_ENC
Hard constraints flag, base pair encloses a multi branch loop.
Definition: constraints.h:213
char * matrix
Upper triangular matrix encoding where a base pair or unpaired nucleotide is allowed.
Definition: constraints.h:379
int * up_int
A linear array that holds the number of allowed unpaired nucleotides in an interior loop...
Definition: constraints.h:388
#define MAXLOOP
Definition: energy_const.h:28
int no_closingGU
GU allowed only inside stacks if set to 1.
struct vrna_param_t * params
The precomputed free energy contributions for each type of loop.
Definition: data_structures.h:712
int * jindx
DP matrix accessor.
Definition: data_structures.h:716
int dangles
Switch the energy model for dangling end contributions (0, 1, 2, 3)
PRIVATE int E_stack(int i, int j, vrna_fold_compound *vc)
Evaluate energy of a base pair stack closed by (i,j)
Definition: interior_loops.h:440
int gquad
Include G-quadruplexes in structure prediction.
Definition: model.h:184
int ** free_energies
Energy contribution for unpaired sequence stretches.
Definition: constraints.h:402
#define MIN2(A, B)
Get the minimum of two comparable values.
Definition: utils.h:118
vrna_md_t model_details
Model details to be used in the recursions.
Definition: params.h:79
The most basic data structure required by many functions throughout the RNAlib.
Definition: data_structures.h:689
#define INF
Definition: energy_const.h:16
#define MAX2(A, B)
Get the maximum of two comparable values.
Definition: utils.h:123
vrna_mx_mfe_t * matrices
The MFE DP matrices.
Definition: data_structures.h:709
int min_loop_size
Minimum size of hairpin loops.
Definition: model.h:194
int dangles
Specifies the dangle model used in any energy evaluation (0,1,2 or 3)
Definition: model.h:172
unsigned int length
The length of the sequence (or sequence alignment)
Definition: data_structures.h:702
#define VRNA_CONSTRAINT_CONTEXT_INT_LOOP
Hard constraints flag, base pair encloses an interior loop.
Definition: constraints.h:205
Various functions related to G-quadruplex computations.
char * ptype
Pair type array.
Definition: data_structures.h:740
The datastructure that contains temperature scaled energy parameters.
Definition: params.h:41
The soft constraints data structure.
Definition: constraints.h:401
The data structure that contains the complete model details used throughout the calculations.
Definition: model.h:169
void * data
A pointer to the data object provided for for pseudo energy contribution functions of the generalized...
Definition: constraints.h:447
Here all all declarations of the global variables used throughout RNAlib.
PRIVATE double 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: interior_loops.h:572
short * sequence_encoding
Numerical encoding of the input sequence.
Definition: data_structures.h:735
struct vrna_sc_t * sc
The soft constraints for usage in structure prediction and evaluation.
Definition: data_structures.h:754
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: interior_loops.h:502
int * en_basepair
Energy contribution for base pairs.
Definition: constraints.h:403
#define VRNA_DECOMP_PAIR_IL
Generalized constraint folding flag indicating interior loop decomposition step.
Definition: constraints.h:262
The datastructure that contains temperature scaled Boltzmann weights of the energy parameters...
Definition: params.h:86
int * en_stack
Pseudo Energy contribution per base pair involved in a stack.
Definition: constraints.h:407
int(* f)(int, int, int, int, char, void *)
A function pointer used for pseudo energy contribution in MFE calculations.
Definition: constraints.h:411