1#ifndef VIENNA_RNA_PACKAGE_GQUAD_H
2#define VIENNA_RNA_PACKAGE_GQUAD_H
40void E_gquad_ali_en(
int i,
70int *get_gquad_ali_matrix(
unsigned int n,
83FLT_OR_DBL *get_gquad_pf_matrix_comparative(
unsigned int n,
92int **get_gquad_L_matrix(
short *S,
104void get_gquad_pattern_mfe(
short *S,
113get_gquad_pattern_exhaustive(
short *S,
122void get_gquad_pattern_pf(
short *S,
130plist *get_plist_gquad_from_pr(
short *S,
139plist *get_plist_gquad_from_pr_max(
short *S,
150plist *get_plist_gquad_from_db(
const char *structure,
168int get_gquad_count(
short *S,
173int get_gquad_layer_count(
short *S,
178void get_gquad_pattern_mfe_ali(
short **S,
216INLINE PRIVATE
int backtrack_GQuad_IntLoop_comparative(
int c,
265 int l[3], L, a, n_seq;
272 S = vc->sequence_encoding2;
275 get_gquad_pattern_mfe(S, i, j, P, &L, l);
281 get_gquad_pattern_mfe_ali(vc->
S, vc->a2s, vc->
S_cons, n_seq, i, j, P, &L, l);
287 for (a = 0; a < L; a++) {
288 bp_stack[++(*stack_count)].i = i + a;
289 bp_stack[(*stack_count)].j = i + a;
290 bp_stack[++(*stack_count)].i = i + L + l[0] + a;
291 bp_stack[(*stack_count)].j = i + L + l[0] + a;
292 bp_stack[++(*stack_count)].i = i + L + l[0] + L + l[1] + a;
293 bp_stack[(*stack_count)].j = i + L + l[0] + L + l[1] + a;
294 bp_stack[++(*stack_count)].i = i + L + l[0] + L + l[1] + L + l[2] + a;
295 bp_stack[(*stack_count)].j = i + L + l[0] + L + l[1] + L + l[2] + a;
315 int energy,
dangles, *idx, ij, p, q, maxl, minl, c0, l1, *ggg;
318 short si, sj, *S, *S1;
328 type = (
unsigned char)ptype[ij];
330 S = vc->sequence_encoding2;
338 energy += P->mismatchI[type][si][sj];
341 energy += P->TerminalAU;
345 if (p < j - VRNA_GQUAD_MIN_BOX_SIZE) {
346 minl = j - i + p -
MAXLOOP - 2;
347 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
348 minl =
MAX2(c0, minl);
350 maxl = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
351 maxl =
MIN2(c0, maxl);
352 for (q = minl; q < maxl; q++) {
356 if (en == energy + ggg[idx[q] + p] + P->internal_loop[j - q - 1])
357 return vrna_BT_gquad_mfe(vc, p, q, bp_stack, stack_count);
363 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
372 minl = j - i + p -
MAXLOOP - 2;
373 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
374 minl =
MAX2(c0, minl);
376 maxl = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
377 maxl =
MIN2(c0, maxl);
378 for (q = minl; q < maxl; q++) {
382 if (en == energy + ggg[idx[q] + p] + P->internal_loop[l1 + j - q - 1])
383 return vrna_BT_gquad_mfe(vc, p, q, bp_stack, stack_count);
390 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
399 if (en == energy + ggg[idx[q] + p] + P->internal_loop[l1])
400 return vrna_BT_gquad_mfe(vc, p, q, bp_stack, stack_count);
436 int energy,
dangles, k, l, maxl, minl, c0, l1;
445 energy += P->mismatchI[type][si][sj];
448 energy += P->TerminalAU;
452 if (k < j - VRNA_GQUAD_MIN_BOX_SIZE) {
453 minl = j - i + k -
MAXLOOP - 2;
454 c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
455 minl =
MAX2(c0, minl);
457 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
458 maxl =
MIN2(c0, maxl);
459 for (l = minl; l < maxl; l++) {
463 if (c == energy + ggg[index[l] + k] + P->internal_loop[j - l - 1]) {
473 k < j - VRNA_GQUAD_MIN_BOX_SIZE;
482 minl = j - i + k -
MAXLOOP - 2;
483 c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
484 minl =
MAX2(c0, minl);
486 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
487 maxl =
MIN2(c0, maxl);
488 for (l = minl; l < maxl; l++) {
492 if (c == energy + ggg[index[l] + k] + P->internal_loop[l1 + j - l - 1]) {
503 k < j - VRNA_GQUAD_MIN_BOX_SIZE;
512 if (c == energy + ggg[index[l] + k] + P->internal_loop[l1]) {
524backtrack_GQuad_IntLoop_comparative(
int c,
539 int energy,
dangles, k, l, maxl, minl, c0, l1, ss, tt, u1, u2, eee;
544 for (ss = 0; ss < n_seq; ss++) {
550 energy += P->mismatchI[tt][S3[ss][i]][S5[ss][j]];
553 energy += P->TerminalAU;
557 if (S_cons[k] == 3) {
558 if (k < j - VRNA_GQUAD_MIN_BOX_SIZE) {
559 minl = j - i + k -
MAXLOOP - 2;
560 c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
561 minl =
MAX2(c0, minl);
563 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
564 maxl =
MIN2(c0, maxl);
565 for (l = minl; l < maxl; l++) {
571 for (ss = 0; ss < n_seq; ss++) {
572 u1 = a2s[ss][j - 1] - a2s[ss][l];
573 eee += P->internal_loop[u1];
576 if (c == energy + ggg[index[l] + k] + eee) {
586 k < j - VRNA_GQUAD_MIN_BOX_SIZE;
595 minl = j - i + k -
MAXLOOP - 2;
596 c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
597 minl =
MAX2(c0, minl);
599 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
600 maxl =
MIN2(c0, maxl);
601 for (l = minl; l < maxl; l++) {
607 for (ss = 0; ss < n_seq; ss++) {
608 u1 = a2s[ss][k - 1] - a2s[ss][i];
609 u2 = a2s[ss][j - 1] - a2s[ss][l];
610 eee += P->internal_loop[u1 + u2];
613 if (c == energy + ggg[index[l] + k] + eee) {
624 k < j - VRNA_GQUAD_MIN_BOX_SIZE;
635 for (ss = 0; ss < n_seq; ss++) {
636 u1 = a2s[ss][k - 1] - a2s[ss][i];
637 eee += P->internal_loop[u1];
640 if (c == energy + ggg[index[l] + k] + eee) {
679 int energy,
dangles, k, l, maxl, minl, c0, l1;
688 energy += P->mismatchI[type][si][sj];
691 energy += P->TerminalAU;
695 if (k < j - VRNA_GQUAD_MIN_BOX_SIZE) {
696 minl = j - i + k -
MAXLOOP - 2;
697 c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
698 minl =
MAX2(c0, minl);
700 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
701 maxl =
MIN2(c0, maxl);
702 for (l = minl; l < maxl; l++) {
706 if (c == energy + ggg[k][l - k] + P->internal_loop[j - l - 1]) {
716 k < j - VRNA_GQUAD_MIN_BOX_SIZE;
725 minl = j - i + k -
MAXLOOP - 2;
726 c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
727 minl =
MAX2(c0, minl);
729 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
730 maxl =
MIN2(c0, maxl);
731 for (l = minl; l < maxl; l++) {
735 if (c == energy + ggg[k][l - k] + P->internal_loop[l1 + j - l - 1]) {
746 k < j - VRNA_GQUAD_MIN_BOX_SIZE;
755 if (c == energy + ggg[k][l - k] + P->internal_loop[l1]) {
767backtrack_GQuad_IntLoop_L_comparative(
int c,
787 int mm, dangle_model, k, l, maxl, minl, c0, l1, ss, tt, eee, u1, u2;
792 for (ss = 0; ss < n_seq; ss++) {
795 if (dangle_model == 2)
796 mm += P->mismatchI[tt][S3[ss][i]][S5[ss][j]];
803 k < j - VRNA_GQUAD_MIN_BOX_SIZE;
812 minl = j - i + k -
MAXLOOP - 2;
813 c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
814 minl =
MAX2(c0, minl);
816 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
817 maxl =
MIN2(c0, maxl);
818 for (l = minl; l < maxl; l++) {
824 for (ss = 0; ss < n_seq; ss++) {
825 u1 = a2s[ss][k - 1] - a2s[ss][i];
826 u2 = a2s[ss][j - 1] - a2s[ss][l];
827 eee += P->internal_loop[u1 + u2];
842 if (S_cons[k] == 3) {
843 if (k < j - VRNA_GQUAD_MIN_BOX_SIZE) {
844 minl = j - i + k -
MAXLOOP - 2;
845 c0 = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
846 minl =
MAX2(c0, minl);
848 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
849 maxl =
MIN2(c0, maxl);
850 for (l = minl; l < maxl; l++) {
856 for (ss = 0; ss < n_seq; ss++) {
857 u1 = a2s[ss][j - 1] - a2s[ss][l];
858 eee += P->internal_loop[u1];
861 if (c == mm + ggg[k][l - k] + eee) {
871 if (S_cons[l] == 3) {
872 for (k = i + 4; k < j - VRNA_GQUAD_MIN_BOX_SIZE; k++) {
882 for (ss = 0; ss < n_seq; ss++) {
883 u1 = a2s[ss][k - 1] - a2s[ss][i];
884 eee += P->internal_loop[u1];
887 if (c == mm + ggg[k][l - k] + eee) {
901E_GQuad_IntLoop(
int i,
909 int energy, ge,
dangles, p, q, l1, minq, maxq, c0;
918 energy += P->mismatchI[type][si][sj];
921 energy += P->TerminalAU;
927 if (p < j - VRNA_GQUAD_MIN_BOX_SIZE) {
928 minq = j - i + p -
MAXLOOP - 2;
929 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
930 minq =
MAX2(c0, minq);
932 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
933 maxq =
MIN2(c0, maxq);
934 for (q = minq; q < maxq; q++) {
938 c0 = energy + ggg[index[q] + p] + P->internal_loop[j - q - 1];
945 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
954 minq = j - i + p -
MAXLOOP - 2;
955 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
956 minq =
MAX2(c0, minq);
958 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
959 maxq =
MIN2(c0, maxq);
960 for (q = minq; q < maxq; q++) {
964 c0 = energy + ggg[index[q] + p] + P->internal_loop[l1 + j - q - 1];
972 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
981 c0 = energy + ggg[index[q] + p] + P->internal_loop[l1];
988 en1 = energy + P->dangle5[type][si];
989 en2 = energy + P->dangle5[type][sj];
990 en3 = energy + P->mismatchI[type][si][sj];
995 if (p < j - VRNA_GQUAD_MIN_BOX_SIZE) {
996 minq = j - i + p -
MAXLOOP - 2;
997 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
998 minq =
MAX2(c0, minq);
1000 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1001 maxq =
MIN2(c0, maxq);
1002 for (q = minq; q < maxq; q++) {
1006 c0 = en1 + ggg[index[q] + p] + P->internal_loop[j - q - 1];
1012 for (p = i + 2; p < j - VRNA_GQUAD_MIN_BOX_SIZE; p++) {
1020 minq = j - i + p -
MAXLOOP - 2;
1021 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1022 minq =
MAX2(c0, minq);
1024 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1025 maxq =
MIN2(c0, maxq);
1026 for (q = minq; q < maxq; q++) {
1030 c0 = en1 + ggg[index[q] + p] + P->internal_loop[l1 + j - q - 1];
1037 for (p = i + 4; p < j - VRNA_GQUAD_MIN_BOX_SIZE; p++) {
1045 c0 = en1 + ggg[index[q] + p] + P->internal_loop[l1 + 1];
1059E_GQuad_IntLoop_comparative(
int i,
1072 int eee, energy, ge, p, q, l1, u1, u2, minq, maxq, c0, s;
1078 for (s = 0; s < n_seq; s++) {
1081 energy += P->mismatchI[type][S3[s][i]][S5[s][j]];
1084 energy += P->TerminalAU;
1090 if (S_cons[p] == 3) {
1091 if (p < j - VRNA_GQUAD_MIN_BOX_SIZE) {
1092 minq = j - i + p -
MAXLOOP - 2;
1093 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1094 minq =
MAX2(c0, minq);
1096 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1097 maxq =
MIN2(c0, maxq);
1098 for (q = minq; q < maxq; q++) {
1104 for (s = 0; s < n_seq; s++) {
1105 u1 = a2s[s][j - 1] - a2s[s][q];
1106 eee += P->internal_loop[u1];
1118 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
1127 minq = j - i + p -
MAXLOOP - 2;
1128 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1129 minq =
MAX2(c0, minq);
1131 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1132 maxq =
MIN2(c0, maxq);
1133 for (q = minq; q < maxq; q++) {
1139 for (s = 0; s < n_seq; s++) {
1140 u1 = a2s[s][p - 1] - a2s[s][i];
1141 u2 = a2s[s][j - 1] - a2s[s][q];
1142 eee += P->internal_loop[u1 + u2];
1155 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
1166 for (s = 0; s < n_seq; s++) {
1167 u1 = a2s[s][p - 1] - a2s[s][i];
1168 eee += P->internal_loop[u1];
1183E_GQuad_IntLoop_L_comparative(
int i,
1195 int eee, energy, ge, p, q, l1, u1, u2, minq, maxq, c0, s;
1201 for (s = 0; s < n_seq; s++) {
1204 energy += P->mismatchI[type][S3[s][i]][S5[s][j]];
1207 energy += P->TerminalAU;
1213 if (S_cons[p] == 3) {
1214 if (p < j - VRNA_GQUAD_MIN_BOX_SIZE) {
1215 minq = j - i + p -
MAXLOOP - 2;
1216 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1217 minq =
MAX2(c0, minq);
1219 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1220 maxq =
MIN2(c0, maxq);
1221 for (q = minq; q < maxq; q++) {
1227 for (s = 0; s < n_seq; s++) {
1228 u1 = a2s[s][j - 1] - a2s[s][q];
1229 eee += P->internal_loop[u1];
1241 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
1250 minq = j - i + p -
MAXLOOP - 2;
1251 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1252 minq =
MAX2(c0, minq);
1254 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1255 maxq =
MIN2(c0, maxq);
1256 for (q = minq; q < maxq; q++) {
1262 for (s = 0; s < n_seq; s++) {
1263 u1 = a2s[s][p - 1] - a2s[s][i];
1264 u2 = a2s[s][j - 1] - a2s[s][q];
1265 eee += P->internal_loop[u1 + u2];
1278 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
1289 for (s = 0; s < n_seq; s++) {
1290 u1 = a2s[s][p - 1] - a2s[s][i];
1291 eee += P->internal_loop[u1];
1306E_GQuad_IntLoop_exhaustive(
int i,
1317 int energy, *ge,
dangles, p, q, l1, minq, maxq, c0;
1327 energy += P->mismatchI[type][si][sj];
1330 energy += P->TerminalAU;
1339 if (p < j - VRNA_GQUAD_MIN_BOX_SIZE) {
1340 minq = j - i + p -
MAXLOOP - 2;
1341 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1342 minq =
MAX2(c0, minq);
1344 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1345 maxq =
MIN2(c0, maxq);
1346 for (q = minq; q < maxq; q++) {
1350 c0 = energy + ggg[index[q] + p] + P->internal_loop[j - q - 1];
1351 if (c0 <= threshold) {
1352 ge[cnt] = energy + P->internal_loop[j - q - 1];
1361 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
1370 minq = j - i + p -
MAXLOOP - 2;
1371 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1372 minq =
MAX2(c0, minq);
1374 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1375 maxq =
MIN2(c0, maxq);
1376 for (q = minq; q < maxq; q++) {
1380 c0 = energy + ggg[index[q] + p] + P->internal_loop[l1 + j - q - 1];
1381 if (c0 <= threshold) {
1382 ge[cnt] = energy + P->internal_loop[l1 + j - q - 1];
1392 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
1401 c0 = energy + ggg[index[q] + p] + P->internal_loop[l1];
1402 if (c0 <= threshold) {
1403 ge[cnt] = energy + P->internal_loop[l1];
1417E_GQuad_IntLoop_L(
int i,
1425 int energy, ge,
dangles, p, q, l1, minq, maxq, c0;
1434 energy += P->mismatchI[type][si][sj];
1437 energy += P->TerminalAU;
1443 if (p < j - VRNA_GQUAD_MIN_BOX_SIZE) {
1444 minq = j - i + p -
MAXLOOP - 2;
1445 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1446 minq =
MAX2(c0, minq);
1448 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1449 maxq =
MIN2(c0, maxq);
1450 for (q = minq; q < maxq; q++) {
1454 c0 = energy + ggg[p][q - p] + P->internal_loop[j - q - 1];
1461 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
1470 minq = j - i + p -
MAXLOOP - 2;
1471 c0 = p + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1472 minq =
MAX2(c0, minq);
1474 maxq = p + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1475 maxq =
MIN2(c0, maxq);
1476 for (q = minq; q < maxq; q++) {
1480 c0 = energy + ggg[p][q - p] + P->internal_loop[l1 + j - q - 1];
1488 p < j - VRNA_GQUAD_MIN_BOX_SIZE;
1497 c0 = energy + ggg[p][q - p] + P->internal_loop[l1];
1507exp_E_GQuad_IntLoop(
int i,
1516 int k, l, minl, maxl, u, r;
1524 qe = (
FLT_OR_DBL)pf->expmismatchI[type][si][sj];
1525 expintern = &(pf->expinternal[0]);
1532 if (k < j - VRNA_GQUAD_MIN_BOX_SIZE) {
1534 u = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1535 minl =
MAX2(u, minl);
1537 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1538 maxl =
MIN2(u, maxl);
1539 for (l = minl; l < maxl; l++) {
1543 if (G[index[k] - l] == 0.)
1555 k <= j - VRNA_GQUAD_MIN_BOX_SIZE;
1564 minl = j - i + k -
MAXLOOP - 2;
1565 r = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1566 minl =
MAX2(r, minl);
1567 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1569 maxl =
MIN2(r, maxl);
1570 for (l = minl; l < maxl; l++) {
1574 if (G[index[k] - l] == 0.)
1580 * scale[u + j - l + 1];
1586 for (k = i + 4; k <= j - VRNA_GQUAD_MIN_BOX_SIZE; k++) {
1594 if (G[index[k] - l] == 0.)
1609exp_E_GQuad_IntLoop_comparative(
int i,
1623 int k, l, minl, maxl, u, u1, u2, r, s;
1631 expintern = &(pf->expinternal[0]);
1633 for (s = 0; s < n_seq; s++) {
1636 qe *= (
FLT_OR_DBL)pf->expmismatchI[type][S3[s][i]][S5[s][j]];
1643 if (S_cons[k] == 3) {
1644 if (k < j - VRNA_GQUAD_MIN_BOX_SIZE) {
1646 u = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1647 minl =
MAX2(u, minl);
1649 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1650 maxl =
MIN2(u, maxl);
1651 for (l = minl; l < maxl; l++) {
1655 if (G[index[k] - l] == 0.)
1660 for (s = 0; s < n_seq; s++) {
1661 u1 = a2s[s][j - 1] - a2s[s][l];
1662 qqq *= expintern[u1];
1674 k <= j - VRNA_GQUAD_MIN_BOX_SIZE;
1683 minl = j - i + k -
MAXLOOP - 2;
1684 r = k + VRNA_GQUAD_MIN_BOX_SIZE - 1;
1685 minl =
MAX2(r, minl);
1686 maxl = k + VRNA_GQUAD_MAX_BOX_SIZE + 1;
1688 maxl =
MIN2(r, maxl);
1689 for (l = minl; l < maxl; l++) {
1693 if (G[index[k] - l] == 0.)
1698 for (s = 0; s < n_seq; s++) {
1699 u1 = a2s[s][k - 1] - a2s[s][i];
1700 u2 = a2s[s][j - 1] - a2s[s][l];
1701 qqq *= expintern[u1 + u2];
1707 scale[u + j - l + 1];
1713 for (k = i + 4; k <= j - VRNA_GQUAD_MIN_BOX_SIZE; k++) {
1721 if (G[index[k] - l] == 0.)
1726 for (s = 0; s < n_seq; s++) {
1727 u1 = a2s[s][k - 1] - a2s[s][i];
1728 qqq *= expintern[u1];
#define INF
Definition: constants.h:17
#define MAXLOOP
Definition: constants.h:29
Various data structures and pre-processor macros.
The Basic Fold Compound API.
FLT_OR_DBL * pr
A pointer to the base pair probability matrix.
double FLT_OR_DBL
Typename for floating point number in partition function computations.
Definition: basic.h:43
Base pair stack element.
Definition: basic.h:143
int * ggg
Energies of g-quadruplexes.
Definition: dp_matrices.h:75
vrna_md_t model_details
Model details to be used in the recursions.
Definition: basic.h:96
vrna_md_t model_details
Model details to be used in the recursions.
Definition: basic.h:154
The data structure that contains temperature scaled Boltzmann weights of the energy parameters.
Definition: basic.h:103
The datastructure that contains temperature scaled energy parameters.
Definition: basic.h:57
vrna_param_t * params
The precomputed free energy contributions for each type of loop.
Definition: fold_compound.h:183
const vrna_fc_type_e type
The type of the vrna_fold_compound_t.
Definition: fold_compound.h:153
char * ptype
Pair type array.
Definition: fold_compound.h:251
int * jindx
DP matrix accessor
Definition: fold_compound.h:187
unsigned int n_seq
The number of sequences in the alignment.
Definition: fold_compound.h:287
short * sequence_encoding
Numerical encoding of the input sequence.
Definition: fold_compound.h:241
short * S_cons
Numerical encoding of the consensus sequence.
Definition: fold_compound.h:293
vrna_mx_mfe_t * matrices
The MFE DP matrices.
Definition: fold_compound.h:180
short ** S
Numerical encoding of the sequences in the alignment.
Definition: fold_compound.h:296
@ VRNA_FC_TYPE_SINGLE
Definition: fold_compound.h:131
@ VRNA_FC_TYPE_COMPARATIVE
Definition: fold_compound.h:132
The most basic data structure required by many functions throughout the RNAlib.
Definition: fold_compound.h:148
PRIVATE int backtrack_GQuad_IntLoop(int c, int i, int j, int type, short *S, int *ggg, int *index, int *p, int *q, vrna_param_t *P)
Definition: gquad.h:425
int * get_gquad_matrix(short *S, vrna_param_t *P)
Get a triangular matrix prefilled with minimum free energy contributions of G-quadruplexes.
PRIVATE int backtrack_GQuad_IntLoop_L(int c, int i, int j, int type, short *S, int **ggg, int maxdist, int *p, int *q, vrna_param_t *P)
Definition: gquad.h:668
int parse_gquad(const char *struc, int *L, int l[3])
int dangles
Specifies the dangle model used in any energy evaluation (0,1,2 or 3)
Definition: model.h:184
int dangles
Switch the energy model for dangling end contributions (0, 1, 2, 3)
The data structure that contains the complete model details used throughout the calculations.
Definition: model.h:180
Data structure representing a single entry of an element probability list (e.g. list of pair probabil...
Definition: structures.h:482
#define MAX2(A, B)
Get the maximum of two comparable values.
Definition: basic.h:111
#define MIN2(A, B)
Get the minimum of two comparable values.
Definition: basic.h:106
void * vrna_alloc(unsigned size)
Allocate space safely.
Functions to deal with sets of energy parameters.