void gt_print_edist_alignment(const GtUchar *useq, GtUword ustart, GtUword ulen,
const GtUchar *vseq, GtUword vstart, GtUword vlen)
{
GtAlignment *align;
align = gt_alignment_new_with_seqs(useq+ustart, ulen, vseq+vstart, vlen);
alignment_in_square_space(NULL, align, useq, ustart, ulen,
vseq, vstart, vlen, 0, 1, 1);
gt_alignment_show(align, true, stdout, 80);
gt_alignment_delete(align);
}
GtAlignment* gt_affinealign(const char *u, unsigned long ulen,
const char *v, unsigned long vlen,
int replacement_cost, int gap_opening_cost,
int gap_extension_cost)
{
AffinealignDPentry **dptable;
GtAlignment *a;
gt_assert(u && ulen && v && vlen);
gt_array2dim_malloc(dptable, ulen+1, vlen+1);
affinealign_fill_table(dptable, u, ulen, v, vlen, replacement_cost,
gap_opening_cost, gap_extension_cost);
a = gt_alignment_new_with_seqs((const GtUchar *) u, ulen, (const GtUchar *) v,
vlen);
affinealign_traceback(a, dptable, ulen, vlen);
gt_array2dim_delete(dptable);
return a;
}
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;
}
GtAlignment* gt_affinealign(const char *u, GtUword ulen,
const char *v, GtUword vlen,
int matchcost, int mismatchcost,
int gap_opening_cost, int gap_extension_cost)
{
AffinealignDPentry **dptable;
GtAlignment *a;
gt_assert(u && v);
/*gt_assert(ulen && vlen);*/
gt_array2dim_malloc(dptable, ulen+1, vlen+1);
affinealign_fill_table(dptable, u, ulen, v, vlen, matchcost, mismatchcost,
gap_opening_cost, gap_extension_cost);
a = gt_alignment_new_with_seqs((const GtUchar *) u, ulen, (const GtUchar *) v,
vlen);
affinealign_traceback(a, dptable, ulen, vlen);
gt_array2dim_delete(dptable);
return a;
}
void gt_checklinearspace(GT_UNUSED bool forward,
const GtUchar *useq,
GtUword ulen,
const GtUchar *vseq,
GtUword vlen)
{
GtAlignment *align;
GtUword edist1, edist2, edist3, edist4,
matchcost = 0, mismatchcost = 1, gapcost = 1;
LinspaceManagement *spacemanager;
GtScoreHandler *scorehandler;
GtUchar *low_useq, *low_vseq;
if (memchr(useq, LINEAR_EDIST_GAP,ulen) != NULL)
{
fprintf(stderr,"%s: sequence u contains gap symbol\n",__func__);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
if (memchr(vseq, LINEAR_EDIST_GAP,vlen) != NULL)
{
fprintf(stderr,"%s: sequence v contains gap symbol\n",__func__);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
scorehandler = gt_scorehandler_new_DNA(matchcost, mismatchcost, 0, gapcost);
GtAlphabet *alphabet = gt_scorehandler_get_alphabet(scorehandler);
low_useq = check_dna_sequence(useq, ulen, alphabet);
low_vseq = check_dna_sequence(vseq, vlen, alphabet);
if (low_useq == NULL || low_vseq == NULL)
{
low_useq? gt_free(low_useq):0;
low_vseq? gt_free(low_vseq):0;
gt_scorehandler_delete(scorehandler);
return;
}
spacemanager = gt_linspaceManagement_new();
align = gt_alignment_new_with_seqs(low_useq, ulen, low_vseq, vlen);
edist1 = gt_calc_linearalign(spacemanager, scorehandler, align,
low_useq, 0, ulen,
low_vseq, 0, vlen);
edist2 = distance_only_global_alignment(useq, 0, ulen, vseq, 0, vlen,
scorehandler);
if (edist1 != edist2)
{
fprintf(stderr,"gt_calc_linearalign = "GT_WU" != "GT_WU
" = distance_only_global_alignment\n", edist1,edist2);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
edist3 = gt_alignment_eval_with_score(align, matchcost,
mismatchcost, gapcost);
if (edist2 != edist3)
{
fprintf(stderr,"distance_only_global_alignment = "GT_WU" != "GT_WU
" = gt_alignment_eval_with_score\n", edist2,edist3);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
edist4 = gt_calc_linearedist(low_useq, ulen, low_vseq, vlen);
if (edist3 != edist4)
{
fprintf(stderr,"gt_alignment_eval_with_score = "GT_WU" != "GT_WU
" = gt_calc_linearedist\n", edist3, edist4);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
gt_free(low_useq);
gt_free(low_vseq);
gt_linspaceManagement_delete(spacemanager);
gt_scorehandler_delete(scorehandler);
gt_alignment_delete(align);
}
void gt_linearalign_check(GT_UNUSED bool forward,
const GtUchar *useq,
GtUword ulen,
const GtUchar *vseq,
GtUword vlen)
{
GtAlignment *align;
GtUword edist1, edist2, edist3, edist4,
matchcost = 0, mismatchcost = 1, gapcost = 1;
GtLinspaceManagement *spacemanager;
GtScoreHandler *scorehandler;
const bool downcase = true;
if (memchr(useq, LINEAR_EDIST_GAP,ulen) != NULL)
{
fprintf(stderr,"%s: sequence u contains gap symbol\n",__func__);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
if (memchr(vseq, LINEAR_EDIST_GAP,vlen) != NULL)
{
fprintf(stderr,"%s: sequence v contains gap symbol\n",__func__);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
scorehandler = gt_scorehandler_new(matchcost, mismatchcost, 0, gapcost);
gt_scorehandler_plain(scorehandler);
gt_scorehandler_downcase(scorehandler);
spacemanager = gt_linspace_management_new();
align = gt_alignment_new_with_seqs(useq, ulen, vseq, vlen);
edist1 = gt_calc_linearalign(spacemanager, scorehandler, align,
useq, 0, ulen,
vseq, 0, vlen);
edist2 = gt_squarealign_global_distance_only(useq, 0, ulen, vseq, 0, vlen,
scorehandler);
if (edist1 != edist2)
{
fprintf(stderr,"gt_calc_linearalign = "GT_WU" != "GT_WU
" = gt_squarealign_global_distance_only\n", edist1,edist2);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
edist3 = gt_alignment_eval_with_score(align, true, matchcost,
mismatchcost, gapcost);
if (edist2 != edist3)
{
fprintf(stderr,"gt_squarealign_global_distance_only = "GT_WU" != "GT_WU
" = gt_alignment_eval_with_score\n", edist2,edist3);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
edist4 = gt_calc_linearedist(downcase,useq, ulen, vseq, vlen);
if (edist3 != edist4)
{
fprintf(stderr,"gt_alignment_eval_with_score = "GT_WU" != "GT_WU
" = gt_calc_linearedist\n", edist3, edist4);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
gt_linspace_management_delete(spacemanager);
gt_scorehandler_delete(scorehandler);
gt_alignment_delete(align);
}
int gt_xdrop_unit_test(GT_UNUSED GtError *err)
{
int had_err = 0, i, j, s;
const GtUchar *strings[GT_XDROP_NUM_OF_TESTS] =
{(const GtUchar*) "TTTTTTTTTTTTTTTAAAGGGTTTCCCAAAGGGTTTCCCTTTTTTTTTTTTTTT",
(const GtUchar*) "TTTTTTTTTTTTTTTTTTTGGGGCCCCAAAATTTTTTTTTTTTTTT",
(const GtUchar*) "TTTTTTTTTTTTTTTNNNNTTTTGGGGCCCCAAAATTTTTTTTTTTTTTT",
(const GtUchar*) "TTTTTTTTTTTTTTTAAAGGGTTTCGCAAAGGGTTTCCCTTTTTTTTTTTTTTT",
(const GtUchar*) "TTTTTTTTTTTTTTTAAAGGGTTTCCAAAGGGTTTCCCCTTTTTTTTTTTTTTT",
(const GtUchar*) "TTTTTTTTTTTTTTTAAAGGGTTTCCTCAAAGGGTTTCCTTTTTTTTTTTTTTT",
(const GtUchar*) "TTTTTTTTTTTTTTTAAACAGATCACCCGCTTTTTTTTTTTTTTTT",
(const GtUchar*) "TTTTTTTTTTTTTTTAAACGGGTTTCTCAAAGGGTTCCCTTTTTTTTTTTTTTT"};
GtUword lengths[GT_XDROP_NUM_OF_TESTS] =
{54UL, 46UL, 50UL, 54UL, 54UL, 54UL, 46UL, 54UL},
eval_scores[GT_XDROP_NUM_OF_TESTS *
GT_XDROP_NUM_OF_TESTS *
GT_XDROP_NUM_OF_TESTS] =
{0, 13UL, 0, 1UL, 4UL, 1UL, 0, 7UL,
13UL, 0, 0, 14UL, 15UL, 14UL, 0, 15UL,
0, 0, 0, 0, 0, 0, 0, 0,
1UL, 14UL, 0, 0, 1UL, 2UL, 0, 1UL,
4UL, 15UL, 0, 1UL, 0, 8UL, 0, 1UL,
1UL, 14UL, 0, 2UL, 8UL, 0, 0, 4UL,
0, 0, 0, 0, 0, 0, 0, 0,
7UL, 15UL, 0, 1UL, 1UL, 4UL, 0, 0,
0, 13UL, 0, 1UL, 4UL, 5UL, 14UL, 7UL,
13UL, 0, 0, 14UL, 15UL, 14UL, 12UL, 15UL,
0, 0, 0, 20UL, 0, 19UL, 17UL, 0,
1UL, 14UL, 20UL, 0, 5UL, 6UL, 15UL, 8UL,
4UL, 15UL, 0, 5UL, 0, 8UL, 15UL, 10UL,
5UL, 14UL, 19UL, 6UL, 8UL, 0, 14UL, 4UL,
14UL, 12UL, 17UL, 15UL, 15UL, 14UL, 0, 14UL,
7UL, 15UL, 0, 8UL, 10UL, 4UL, 14UL, 0,
0, 13UL, 19UL, 1UL, 2UL, 2UL, 13UL, 3UL,
13UL, 0, 9UL, 14UL, 14UL, 13UL, 12UL, 14UL,
17UL, 4UL, 0, 18UL, 19UL, 16UL, 16UL, 18UL,
1UL, 14UL, 18UL, 0, 2UL, 3UL, 13UL, 3UL,
2UL, 14UL, 18UL, 2UL, 0, 4UL, 13UL, 4UL,
2UL, 13UL, 19UL, 3UL, 4UL, 0, 13UL, 3UL,
14UL, 12UL, 17UL, 13UL, 13UL, 14UL, 0, 14UL,
3UL, 14UL, 18UL, 3UL, 4UL, 3UL, 13UL, 0,
0, 13UL, 17UL, 1UL, 2UL, 2UL, 14UL, 3UL,
13UL, 0, 4UL, 14UL, 15UL, 13UL, 12UL, 14UL,
19UL, 9UL, 0, 18UL, 18UL, 19UL, 17UL, 18UL,
1UL, 14UL, 18UL, 0, 2UL, 3UL, 13UL, 3UL,
2UL, 14UL, 19UL, 2UL, 0, 4UL, 13UL, 4UL,
2UL, 13UL, 16UL, 3UL, 4UL, 0, 14UL, 3UL,
13UL, 12UL, 16UL, 13UL, 13UL, 13UL, 0, 13UL,
3UL, 14UL, 18UL, 3UL, 4UL, 3UL, 14UL, 0,
0, 0, 0, 1UL, 1UL, 1UL, 0, 1UL,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
1UL, 0, 0, 0, 1UL, 0, 0, 1UL,
1UL, 0, 0, 1UL, 0, 0, 0, 1UL,
1UL, 0, 0, 0, 0, 0, 0, 1UL,
0, 0, 0, 0, 0, 0, 0, 0,
1UL, 0, 0, 1UL, 1UL, 1UL, 0, 0,
0, 0, 0, 1UL, 1UL, 1UL, 0, 1UL,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
1UL, 0, 0, 0, 1UL, 2UL, 0, 1UL,
1UL, 0, 0, 1UL, 0, 0, 0, 1UL,
1UL, 0, 0, 2UL, 0, 0, 0, 1UL,
0, 0, 0, 0, 0, 0, 0, 0,
1UL, 0, 0, 1UL, 1UL, 1UL, 0, 0,
0, 13UL, 17UL, 1UL, 2UL, 2UL, 13UL, 3UL,
13UL, 0, 4UL, 14UL, 14UL, 13UL, 12UL, 14UL,
17UL, 4UL, 0, 18UL, 19UL, 16UL, 16UL, 19UL,
1UL, 14UL, 18UL, 0, 2UL, 3UL, 13UL, 3UL,
2UL, 14UL, 19UL, 2UL, 0, 4UL, 13UL, 4UL,
2UL, 13UL, 16UL, 3UL, 4UL, 0, 13UL, 3UL,
13UL, 12UL, 16UL, 13UL, 13UL, 13UL, 0, 13UL,
3UL, 14UL, 19UL, 3UL, 4UL, 3UL, 13UL, 0,
0, 13UL, 0, 1UL, 2UL, 2UL, 5UL, 3UL,
13UL, 0, 0, 14UL, 15UL, 13UL, 0, 14UL,
0, 0, 0, 0, 0, 0, 0, 0,
1UL, 14UL, 0, 0, 2UL, 3UL, 5UL, 3UL,
2UL, 15UL, 0, 2UL, 0, 4UL, 5UL, 4UL,
2UL, 13UL, 0, 3UL, 4UL, 0, 6UL, 3UL,
5UL, 0, 0, 5UL, 5UL, 6UL, 0, 5UL,
3UL, 14UL, 0, 3UL, 4UL, 3UL, 5UL, 0};
GtSeqabstract *useq, *vseq;
GtXdropArbitraryscores score[GT_XDROP_NUM_OF_TESTS] = {{2, -2, -2, -2},
{2, -1, -1, -1},
{2, -1, -5, -2},
{2, -1, -2, -5},
{3, -2, -3, -3},
{3, -1, -1, -1},
{4, -1, -3, -3},
{10, -3, -8, -8}};
GtXdropresources *resources;
GtXdropbest best;
GtXdropscore dropscore = (GtXdropscore) 12;
GtMultieoplist *edit_ops = NULL;
GtAlignment *alignment;
bool rightextension = true;
gt_error_check(err);
for (s = 0; s < GT_XDROP_NUM_OF_TESTS; ++s) {
resources = gt_xdrop_resources_new(&score[s]);
for (i = 0; i < GT_XDROP_NUM_OF_TESTS && !had_err; ++i) {
for (j = 0; j < GT_XDROP_NUM_OF_TESTS; ++j) {
useq = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
strings[i], lengths[i], 0,lengths[i]);
vseq = gt_seqabstract_new_gtuchar(rightextension, GT_READMODE_FORWARD,
strings[j], lengths[j], 0,lengths[j]);
gt_evalxdroparbitscoresextend(true, &best, resources, useq, vseq,
dropscore);
edit_ops = gt_xdrop_backtrack(resources, &best);
gt_ensure(edit_ops != NULL);
alignment = gt_alignment_new_with_seqs(strings[i], best.ivalue,
strings[j], best.jvalue);
gt_alignment_set_multieop_list(alignment, edit_ops);
gt_ensure(eval_scores[s*64+i*8+j] == gt_alignment_eval(alignment));
gt_multieoplist_delete(edit_ops);
gt_alignment_delete(alignment);
if (i == j) {
gt_evalxdroparbitscoresextend(false, &best, resources, useq, vseq,
dropscore);
edit_ops = gt_xdrop_backtrack(resources, &best);
alignment = gt_alignment_new_with_seqs(strings[i], best.ivalue,
strings[j], best.jvalue);
gt_alignment_set_multieop_list(alignment, edit_ops);
gt_ensure(eval_scores[s*64+i*8+j] == gt_alignment_eval(alignment));
gt_multieoplist_delete(edit_ops);
gt_alignment_delete(alignment);
}
gt_seqabstract_delete(useq);
gt_seqabstract_delete(vseq);
}
}
gt_xdrop_resources_delete(resources);
}
return had_err;
}
