int gt_drawing_range_compare(GtDrawingRange range_a, GtDrawingRange range_b)
{
gt_assert(range_a.start <= range_a.end && range_b.start <= range_b.end);
if (gt_double_equals_double(range_a.start, range_b.start) &&
gt_double_equals_double(range_a.end, range_b.end))
return 0; /* range_a == range_b */
if (gt_double_smaller_double(range_a.start, range_b.start) ||
(gt_double_equals_double(range_a.start, range_b.start)
&& gt_double_smaller_double(range_a.end, range_b.end)))
return -1; /* range_a < range_b */
return 1; /* range_a > range_b */
}
static double expShulen(double T, /* absolute error */
double M, /* min logarithm */
double d,
double p,
GtUword subjectLength,
double *ln_n_fac,
double *s1,
GtUword n_s)
{
GtUword i;
int thresholdReached = 0;
double prob_i, probOld, delta, factor;
double e = 0.0; /* expectation */
double t = 1.0 - d;
double p_t = t;
probOld = 0.0;
/*since for i = 0, the whole expression is 0*/
for (i = 1LU; i < subjectLength; i++) {
factor = 1.0 - p_t;
if (!thresholdReached) {
prob_i = factor * pmax(M, i, p,
subjectLength,
&thresholdReached,
ln_n_fac,
s1,
n_s);
}
else
prob_i = factor; /* prob_i = factor * s, where s = 1 */
delta = (prob_i - probOld) * i; /* delta should always be positive */
gt_assert(gt_double_equals_double(delta, 0.0) ||
gt_double_larger_double(delta, 0.0));
e += delta; /* expectation of avg shulen length(Q, S) */
/* check error */
if (1.0 <= e && delta / e <= T)
break;
p_t *= t;
probOld = prob_i;
}
return e;
}
/* This function orders GtElements by z-index or type. This enables the sketch
function to paint elements in a specific order based on their type
(painter's algorithm-like) */
static int elemcmp(const void *a, const void *b, void *data)
{
const char *type_a, *type_b;
double zindex_a = GT_UNDEF_DOUBLE, zindex_b= GT_UNDEF_DOUBLE;
GtStyle *sty = (GtStyle*) data;
GtElement *elem_a = *(GtElement**) a;
GtElement *elem_b = *(GtElement**) b;
type_a = gt_element_get_type(elem_a);
type_b = gt_element_get_type(elem_b);
/* same types are equal, no further action needed */
if (type_a == type_b)
return 0;
/* if not, then get z-index from style */
if (sty)
{
(void) gt_style_get_num(sty, type_a, "z_index", &zindex_a, NULL, NULL);
(void) gt_style_get_num(sty, type_b, "z_index", &zindex_b, NULL, NULL);
}
/* only one is set -> put types with set z-indices always on top of others*/
if (zindex_a == GT_UNDEF_DOUBLE && zindex_b != GT_UNDEF_DOUBLE)
return -1;
if (zindex_b == GT_UNDEF_DOUBLE && zindex_a != GT_UNDEF_DOUBLE)
return 1;
/* none is set, fall back to default alphabetic ordering */
if (zindex_a == GT_UNDEF_DOUBLE && zindex_b == GT_UNDEF_DOUBLE)
{
if (strcmp(type_a, type_b) < 0)
return 1;
return -1;
}
/* both z-indices are set */
if (gt_double_equals_double(zindex_a, zindex_b))
return 0;
if (gt_double_smaller_double(zindex_a, zindex_b))
return -1;
return 1;
}
bool gth_sas_are_equal(const GthSA *saA, const GthSA *saB)
{
Exoninfo *exoninfoA, *exoninfoB;
Introninfo *introninfoA, *introninfoB;
GtUword i;
/* compare element 0 */
if (gth_sa_alphatype(saA) != gth_sa_alphatype(saB))
return false;
/* compare element 1 */
if (gth_backtrace_path_length(saA->backtrace_path) !=
gth_backtrace_path_length(saB->backtrace_path)) {
return false;
}
for (i = 0; i < gth_backtrace_path_length(saA->backtrace_path); i++) {
if (((Editoperation*) gth_backtrace_path_get(saA->backtrace_path))[i] !=
((Editoperation*) gth_backtrace_path_get(saB->backtrace_path))[i]) {
return false;
}
}
/* element 2 has been removed (indelcount) */
/* compare element 3 */
if (gth_sa_gen_dp_length(saA) != gth_sa_gen_dp_length(saB))
return false;
/* compare element 4 */
if (saA->gen_total_length != saB->gen_total_length)
return false;
/* compare element 5 */
if (saA->gen_offset != saB->gen_offset)
return false;
/* compare element 6 */
if (gth_sa_ref_total_length(saA) != gth_sa_ref_total_length(saB))
return false;
/* compare element 7 */
if (gth_sa_gen_dp_start(saA) != gth_sa_gen_dp_start(saB))
return false;
/* element 8 has been removed (gen_dp_end) */
/* compare element 9 */
if (saA->gen_file_num != saB->gen_file_num)
return false;
/* compare element 10 */
if (saA->gen_seq_num != saB->gen_seq_num)
return false;
/* compare element 11 */
if (saA->ref_file_num != saB->ref_file_num)
return false;
/* compare element 12 */
if (saA->ref_seq_num != saB->ref_seq_num)
return false;
/* compare element 13 */
if (gt_str_cmp(saA->gen_id, saB->gen_id))
return false;
/* compare element 14 */
if (gt_str_cmp(saA->ref_id, saB->ref_id))
return false;
/* compare element 15 */
if (saA->gen_strand_forward != saB->gen_strand_forward)
return false;
/* compare element 16 */
if (saA->ref_strand_forward != saB->ref_strand_forward)
return false;
/* compare element 17 */
if (gth_sa_genomiccutoff_start(saA) != gth_sa_genomiccutoff_start(saB))
return false;
if (gth_sa_referencecutoff_start(saA) != gth_sa_referencecutoff_start(saB))
return false;
if (gth_sa_eopcutoff_start(saA) != gth_sa_eopcutoff_start(saB))
return false;
if (gth_sa_genomiccutoff_end(saA) != gth_sa_genomiccutoff_end(saB))
return false;
if (gth_sa_referencecutoff_end(saA) != gth_sa_referencecutoff_end(saB))
return false;
if (gth_sa_eopcutoff_end(saA) != gth_sa_eopcutoff_end(saB))
return false;
/* compare element 18 */
if (gt_array_size(saA->exons) != gt_array_size(saB->exons))
return false;
for (i = 0; i < gt_array_size(saA->exons); i++) {
exoninfoA = (Exoninfo*) gt_array_get(saA->exons, i);
exoninfoB = (Exoninfo*) gt_array_get(saB->exons, i);
if (exoninfoA->leftgenomicexonborder != exoninfoB->leftgenomicexonborder)
return false;
if (exoninfoA->rightgenomicexonborder != exoninfoB->rightgenomicexonborder)
return false;
if (exoninfoA->leftreferenceexonborder !=
exoninfoB->leftreferenceexonborder) {
return false;
}
if (exoninfoA->rightreferenceexonborder !=
exoninfoB->rightreferenceexonborder) {
return false;
}
if (!gt_double_equals_double(exoninfoA->exonscore, exoninfoB->exonscore)) {
return false;
}
}
/* compare element 19 */
if (gt_array_size(saA->introns) != gt_array_size(saB->introns))
return false;
for (i = 0; i < gt_array_size(saA->introns); i++) {
introninfoA = (Introninfo*) gt_array_get(saA->introns, i);
introninfoB = (Introninfo*) gt_array_get(saB->introns, i);
if (!gt_double_equals_double(introninfoA->donorsiteprobability,
introninfoB->donorsiteprobability)) {
return false;
}
if (!gt_double_equals_double(introninfoA->acceptorsiteprobability,
introninfoB->acceptorsiteprobability)) {
return false;
}
if (!gt_double_equals_double(introninfoA->donorsitescore,
introninfoB->donorsitescore)) {
return false;
}
if (!gt_double_equals_double(introninfoA->acceptorsitescore,
introninfoB->acceptorsitescore)) {
return false;
}
}
/* compare element 20 */
if (saA->polyAtailpos.start != saB->polyAtailpos.start)
return false;
if (saA->polyAtailpos.end != saB->polyAtailpos.end)
return false;
/* compare element 21 */
if (saA->alignmentscore != saB->alignmentscore)
return false;
/* compare element 22 */
if (saA->coverage != saB->coverage)
return false;
/* compare element 23 */
if (saA->genomic_cov_is_highest != saB->genomic_cov_is_highest)
return false;
/* compare element 24 */
if (saA->cumlen_scored_exons != saB->cumlen_scored_exons)
return false;
return true;
}
int gt_encseq_gc_unit_test(GtError *err)
{
int had_err = 0;
double *results;
GtEncseqBuilder *eb;
GtEncseq *encseq;
const char testseq1[] = "aaaaaa",
testseq2[] = "cccccc",
testseq3[] = "acgtacgt",
testseq4[] = "acgtn";
/* testseq5[] = "xxxxn"; */
GtAlphabet *alpha;
/*GtError *tmp_err;*/
gt_error_check(err);
alpha = gt_alphabet_new_dna();
/* test a-seq */
eb = gt_encseq_builder_new(alpha);
gt_encseq_builder_create_ssp_tab(eb);
gt_encseq_builder_enable_description_support(eb);
gt_encseq_builder_add_cstr(eb, testseq1, 6UL, "only a");
encseq = gt_encseq_builder_build(eb, err);
if ((results = gt_encseq_get_gc(encseq,
false,
true,
err)) != NULL)
{
gt_ensure(had_err, gt_double_equals_double(results[0], 0.0));
}
else
{
had_err = -1;
}
gt_free(results);
gt_encseq_builder_delete(eb);
gt_encseq_delete(encseq);
if (!had_err)
{
/* test c-seq */
eb = gt_encseq_builder_new(alpha);
gt_encseq_builder_create_ssp_tab(eb);
gt_encseq_builder_enable_description_support(eb);
gt_encseq_builder_add_cstr(eb, testseq2, 6UL, "only c");
encseq = gt_encseq_builder_build(eb, err);
if ((results = gt_encseq_get_gc(encseq,
false,
true,
err)) != NULL)
{
gt_ensure(had_err, gt_double_equals_one(results[0]));
}
else
{
had_err = -1;
}
gt_free(results);
gt_encseq_builder_delete(eb);
gt_encseq_delete(encseq);
}
if (!had_err)
{
/* test dna-seq and dna+special-seq*/
eb = gt_encseq_builder_new(alpha);
gt_encseq_builder_create_ssp_tab(eb);
gt_encseq_builder_enable_description_support(eb);
gt_encseq_builder_add_cstr(eb, testseq3, 8UL, "0.5");
gt_encseq_builder_add_cstr(eb, testseq4, 5UL, "0.5+special");
encseq = gt_encseq_builder_build(eb, err);
if ((results = gt_encseq_get_gc(encseq,
false,
true,
err)) != NULL)
{
gt_ensure(had_err, gt_double_equals_double(results[0], 0.5));
gt_ensure(had_err, gt_double_equals_double(results[1], 0.5));
}
else
{
had_err = -1;
}
gt_free(results);
if (!had_err)
{
/* count special chars */
if ((results = gt_encseq_get_gc(encseq,
true,
true,
err)) != NULL)
{
gt_ensure(had_err, gt_double_equals_double(results[0], 0.5));
gt_ensure(had_err, gt_double_equals_double(results[1], (2.0/5.0)));
}
else
{
had_err = -1;
}
gt_free(results);
}
gt_encseq_builder_delete(eb);
gt_encseq_delete(encseq);
}
if (!had_err)
{
/* test dna-seq and dna+special-seq*/
eb = gt_encseq_builder_new(alpha);
gt_encseq_builder_create_ssp_tab(eb);
gt_encseq_builder_enable_description_support(eb);
gt_encseq_builder_add_cstr(eb, testseq3, 8UL, "0.5");
gt_encseq_builder_add_cstr(eb, testseq4, 5UL, "0.5+special");
encseq = gt_encseq_builder_build(eb, err);
/*add mirrored sequence*/
had_err = gt_encseq_mirror(encseq, err);
/* sequence wise */
if ((results = gt_encseq_get_gc(encseq,
false,
true,
err)) != NULL)
{
gt_ensure(had_err, gt_double_equals_double(results[0], 0.5));
gt_ensure(had_err, gt_double_equals_double(results[1], 0.5));
gt_ensure(had_err, gt_double_equals_double(results[2], 0.5));
gt_ensure(had_err, gt_double_equals_double(results[3], 0.5));
}
else
{
had_err = -1;
}
gt_free(results);
if (!had_err)
{
/* count special chars */
if ((results = gt_encseq_get_gc(encseq,
true,
true,
err)) != NULL)
{
gt_ensure(had_err, gt_double_equals_double(results[0], 0.5));
gt_ensure(had_err, gt_double_equals_double(results[1], (2.0/5.0)));
gt_ensure(had_err, gt_double_equals_double(results[2], (2.0/5.0)));
gt_ensure(had_err, gt_double_equals_double(results[3], 0.5));
}
else
{
had_err = -1;
}
gt_free(results);
}
gt_encseq_builder_delete(eb);
gt_encseq_delete(encseq);
}
gt_alphabet_delete(alpha);
return had_err;
}
int gt_mathsupport_unit_test(GtError *err)
{
int had_err = 0;
double less_than_epsilon = 0.0000000000000001;
gt_error_check(err);
gt_ensure(had_err, !gt_double_equals_one(1.1));
gt_ensure(had_err, gt_double_equals_one(1));
gt_ensure(had_err, gt_double_equals_one(1+less_than_epsilon));
gt_ensure(had_err, !gt_double_equals_one(-1-less_than_epsilon));
gt_ensure(had_err, !gt_double_equals_double(1.0, 2.0));
gt_ensure(had_err, !gt_double_equals_double(-1.0, 1.0));
gt_ensure(had_err, !gt_double_equals_double(1.0, -1.0));
gt_ensure(had_err, !gt_double_equals_double(-1.0, 1+less_than_epsilon));
gt_ensure(had_err, !gt_double_equals_double(1.0, 1.1));
gt_ensure(had_err, gt_double_equals_double(1.0, 1+less_than_epsilon));
gt_ensure(had_err, gt_double_equals_double(1.0, 1.0));
gt_ensure(had_err, gt_double_equals_double(0.0, 0.0));
gt_ensure(had_err, gt_double_equals_double(-1.0, -1.0));
gt_ensure(had_err, gt_double_equals_double(-1.0+less_than_epsilon, -1.0));
gt_ensure(had_err, gt_double_equals_double(-1.0, -1.0+less_than_epsilon));
gt_ensure(had_err, gt_double_equals_double(1.0+less_than_epsilon, 1.0));
gt_ensure(had_err, gt_double_equals_double(1.0, 1.0+less_than_epsilon));
gt_ensure(had_err, gt_double_compare(1.0, 1.0) == 0);
gt_ensure(had_err, gt_double_compare(1.0, 1.1) < 0);
gt_ensure(had_err, gt_double_compare(1.1, 1.0) > 0);
gt_ensure(had_err, gt_double_compare(1.1, -1.0) > 0);
gt_ensure(had_err, gt_double_compare(-1.1, -1.0) < 0);
gt_ensure(had_err, gt_double_compare(1+less_than_epsilon, 1.0) == 0);
gt_ensure(had_err, gt_double_compare(1+less_than_epsilon, -1.0) > 0);
gt_ensure(had_err, gt_double_compare(-1+less_than_epsilon, -1.0) == 0);
gt_ensure(had_err, gt_double_compare(-1+less_than_epsilon, 1.0) < 0);
gt_ensure(had_err, gt_double_smaller_double(1.0, 1.1));
gt_ensure(had_err, gt_double_smaller_double(-1.0, 1.1));
gt_ensure(had_err, gt_double_smaller_double(-1.1, -1.0));
gt_ensure(had_err, !gt_double_smaller_double(-1.0, -1.1));
gt_ensure(had_err, !gt_double_smaller_double(1.0-less_than_epsilon, 1.0));
return had_err;
}
