void gt_processelemLocaliTracebackstate(Limdfsconstinfo *lci,
GtUchar currentchar,
const void *aliasstate)
{
LocaliTracebackstate *tbs = &lci->tbs;
const LocaliColumn *column = (const LocaliColumn *) aliasstate;
while (true)
{
/*
printf(" coord(i="GT_WU",j="GT_WU") with ",tbs->querypos,
(GtUword) tbs->dbcurrent);
printf("cellvalue="GT_WD", ",column->colvalues[tbs->querypos].bestcell);
*/
switch (column->colvalues[tbs->querypos].tracebit)
{
case Insertbit:
/* printf("insertbit\n"); */
gt_alignment_add_insertion(tbs->alignment);
gt_assert(tbs->dbcurrent > 0);
tbs->dbcurrent--;
tbs->spaceGtUchardbsubstring[tbs->dbcurrent] = currentchar;
return;
case Replacebit:
/* printf("replacebit\n"); */
gt_alignment_add_replacement(tbs->alignment);
gt_assert(tbs->dbcurrent > 0);
tbs->dbcurrent--;
tbs->spaceGtUchardbsubstring[tbs->dbcurrent] = currentchar;
gt_assert(tbs->querypos > 0);
tbs->querypos--;
return;
case Deletebit:
/* printf("deletebit\n"); */
gt_alignment_add_deletion(tbs->alignment);
gt_assert(tbs->querypos > 0);
tbs->querypos--;
break; /* stay in the same column => so next iteration */
case Notraceback:
fprintf(stderr,"tracebit = Notraceback not allowed\n");
fprintf(stderr,"column->colvalues[tbs->querypos].bestcell="GT_WD"\n",
column->colvalues[tbs->querypos].bestcell);
exit(GT_EXIT_PROGRAMMING_ERROR);
default:
fprintf(stderr,"tracebit = %d not allowed\n",
(int) column->colvalues[tbs->querypos].tracebit);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
}
}
int gt_alignment_unit_test(GtError *err)
{
static char u[] = "acgtagatatatagat",
v[] = "agaaagaggtaagaggga";
GtAlignment *alignment;
int had_err = 0;
gt_error_check(err);
/* construct the following alignment (backwards):
acgtaga--tatata-gat
| ||| || | | | [R 7,I 2,R 2,D 1,R 3,I 1,R 3]
agaaagaggta-agaggga
*/
alignment = gt_alignment_new_with_seqs((const GtUchar *) u,
(GtUword) strlen(u),
(const GtUchar *) v,
(GtUword) strlen(v));
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_insertion(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_deletion(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_insertion(alignment);
gt_alignment_add_insertion(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_ensure(gt_alignment_eval(alignment) == 10UL);
gt_alignment_delete(alignment);
return had_err;
}
static void affinealign_traceback(GtAlignment *a,
AffinealignDPentry * const *dptable,
GtUword i, GtUword j)
{
GtUword minvalue;
AffineAlignEdge edge;
gt_assert(a && dptable);
/* determine min{A_affine(m,n,x) | x in {R,D,I}} */
minvalue = MIN3(dptable[i][j].Rdist, dptable[i][j].Ddist,
dptable[i][j].Idist);
if (dptable[i][j].Rdist == minvalue)
edge = Affine_R;
else if (dptable[i][j].Ddist == minvalue)
edge = Affine_D;
else /* dptable[i][j].Idist == minvalue */
edge = Affine_I;
/* backtracing */
while (i > 0 || j > 0) {
switch (edge) {
case Affine_R:
gt_assert(dptable[i][j].Rdist != ULONG_MAX);
gt_alignment_add_replacement(a);
edge = dptable[i][j].Redge;
gt_assert(i > 0 && j > 0);
i--;
j--;
break;
case Affine_D:
gt_alignment_add_deletion(a);
edge = dptable[i][j].Dedge;
gt_assert(i);
i--;
break;
case Affine_I:
gt_alignment_add_insertion(a);
edge = dptable[i][j].Iedge;
gt_assert(j);
j--;
break;
default:
gt_assert(false);
}
}
}
static void swtracebackDPedges(GtAlignment *alignment,
GtUword ulen,
const GtEncseq *encseq,
GtUword vlen,
GtUchar *dbsubstring,
GtUword startpos,
const Retracebits *edges)
{
const Retracebits *eptr = edges + (ulen+1) * (vlen+1) - 1;
while (true)
{
if (*eptr & DELETIONBIT)
{
gt_alignment_add_deletion(alignment);
eptr--;
} else
{
if (*eptr & REPLACEMENTBIT)
{
gt_alignment_add_replacement(alignment);
eptr -= (ulen+2);
} else
{
if (*eptr & INSERTIONBIT)
{
gt_alignment_add_insertion(alignment);
eptr -= (ulen+1);
} else
{
break;
}
}
gt_assert(vlen > 0);
vlen--;
dbsubstring[vlen] = gt_encseq_get_encoded_char(encseq,
startpos + vlen,
GT_READMODE_FORWARD);
}
}
}
static void affinealign_traceback(GtAlignment *a, AffinealignDPentry **dptable,
unsigned long i, unsigned long j)
{
unsigned long minvalue;
Edge edge;
gt_assert(a && dptable);
/* determine min{A_affine(m,n,x) | x in {R,D,I}} */
minvalue = MIN3(dptable[i][j].Rdist, dptable[i][j].Ddist,
dptable[i][j].Idist);
if (dptable[i][j].Rdist == minvalue)
edge = R;
else if (dptable[i][j].Ddist == minvalue)
edge = D;
else /* dptable[i][j].Idist == minvalue */
edge = I;
/* backtracing */
while (i > 0 || j > 0) {
switch (edge) {
case R:
gt_assert(dptable[i][j].Rdist != ULONG_MAX);
gt_alignment_add_replacement(a);
edge = dptable[i][j].Redge;
/* gt_assert(i && j); */
i--;
j--;
break;
case D:
gt_alignment_add_deletion(a);
edge = dptable[i][j].Dedge;
gt_assert(i);
i--;
break;
case I:
gt_alignment_add_insertion(a);
edge = dptable[i][j].Iedge;
gt_assert(j);
j--;
break;
}
}
}
