static void gtf_visitor_free(GtNodeVisitor *nv) { GtGTFVisitor *gtf_visitor = gtf_visitor_cast(nv); gt_assert(gtf_visitor); gt_array_delete(gtf_visitor->exon_features); gt_array_delete(gtf_visitor->CDS_features); }
static bool chain_is_filled_and_consistent(GthChain *chain, unsigned long gen_total_length, unsigned long gen_offset) { GtArray *testranges; /* check of file sequence numbers are defined */ if (chain->gen_file_num == GT_UNDEF_ULONG || chain->gen_seq_num == GT_UNDEF_ULONG || chain->ref_file_num == GT_UNDEF_ULONG || chain->ref_seq_num == GT_UNDEF_ULONG) { return false; } if (!gt_ranges_are_consecutive(chain->forwardranges)) return false; testranges = gt_array_new(sizeof (GtRange)); gt_ranges_copy_to_opposite_strand(testranges, chain->reverseranges, gen_total_length, gen_offset); if (!gt_ranges_are_equal(testranges, chain->forwardranges)) { gt_array_delete(testranges); return false; } gt_array_delete(testranges); return true; }
static void snp_annotator_stream_free(GtNodeStream *ns) { GtUword i; GtSNPAnnotatorStream *sas; if (!ns) return; sas = gt_snp_annotator_stream_cast(ns); gt_region_mapping_delete(sas->rmap); while (gt_queue_size(sas->snps) > 0) { gt_genome_node_delete((GtGenomeNode*) gt_queue_get(sas->snps)); } while (gt_queue_size(sas->outqueue) > 0) { gt_genome_node_delete((GtGenomeNode*) gt_queue_get(sas->outqueue)); } for (i = 0; i < gt_array_size(sas->instreams); i++) { gt_node_stream_delete(*(GtNodeStream**) gt_array_get(sas->instreams, i)); } for (i = 0; i < gt_array_size(sas->cur_gene_set); i++) { gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(sas->cur_gene_set, i)); } gt_array_delete(sas->cur_gene_set); gt_node_stream_delete(sas->merge_stream); gt_array_delete(sas->instreams); gt_queue_delete(sas->snps); gt_queue_delete(sas->outqueue); }
void gt_type_node_delete(GtTypeNode *type_node) { if (!type_node) return; gt_hashmap_delete(type_node->cache); gt_array_delete(type_node->is_a_out_edges); gt_array_delete(type_node->part_of_list); gt_array_delete(type_node->is_a_list); gt_free(type_node); }
void gth_chain_delete(GthChain *chain) { if (!chain) return; if (chain->jump_table_delete) { chain->jump_table_delete(chain->reverse_jump_table); chain->jump_table_delete(chain->forward_jump_table); } gt_array_delete(chain->forwardranges); gt_array_delete(chain->reverseranges); gt_free(chain); }
static void gt_hmmer_model_hit_delete(GtHMMERModelHit *mh) { unsigned long i; if (!mh) return; for (i = 0; i < gt_array_size(mh->fwd_hits); i++) gt_free(*(GtHMMERSingleHit**) gt_array_get(mh->fwd_hits, i)); gt_array_delete(mh->fwd_hits); for (i = 0; i < gt_array_size(mh->rev_hits); i++) gt_free(*(GtHMMERSingleHit**) gt_array_get(mh->rev_hits, i)); gt_array_delete(mh->rev_hits); gt_free(mh); }
static void gv_test_introns_confirmed(AgnUnitTest *test) { GtGenomeNode *intron, *gap; GtStr *seqid = gt_str_new_cstr("chr"); GtArray *introns = gt_array_new( sizeof(GtGenomeNode *) ); intron = gt_feature_node_new(seqid, "intron", 1000, 1170, GT_STRAND_REVERSE); gt_array_add(introns, intron); intron = gt_feature_node_new(seqid, "intron", 1225, 1305, GT_STRAND_REVERSE); gt_array_add(introns, intron); intron = gt_feature_node_new(seqid, "intron", 1950, 2110, GT_STRAND_REVERSE); gt_array_add(introns, intron); intron = gt_feature_node_new(seqid, "intron", 2545, 2655, GT_STRAND_REVERSE); gt_array_add(introns, intron); intron = gt_feature_node_new(seqid, "intron", 2800, 2950, GT_STRAND_REVERSE); gt_array_add(introns, intron); GtArray *gaps = gt_array_new( sizeof(GtGenomeNode *) ); double intcon = gaeval_visitor_introns_confirmed(introns, gaps); bool test1 = fabs(intcon - 0.0) < 0.0001; agn_unit_test_result(test, "introns confirmed (no gaps)", test1); gap = gt_feature_node_new(seqid, "match_gap", 1000, 1170, GT_STRAND_REVERSE); gt_array_add(gaps, gap); gap = gt_feature_node_new(seqid, "match_gap", 1225, 1302, GT_STRAND_REVERSE); gt_array_add(gaps, gap); gap = gt_feature_node_new(seqid, "match_gap", 1950, 2110, GT_STRAND_REVERSE); gt_array_add(gaps, gap); gap = gt_feature_node_new(seqid, "match_gap", 2575, 2655, GT_STRAND_REVERSE); gt_array_add(gaps, gap); gap = gt_feature_node_new(seqid, "match_gap", 2800, 2950, GT_STRAND_REVERSE); gt_array_add(gaps, gap); intcon = gaeval_visitor_introns_confirmed(introns, gaps); bool test2 = fabs(intcon - 0.6) < 0.0001; agn_unit_test_result(test, "introns confirmed (gaps)", test2); while(gt_array_size(introns) > 0) { intron = *(GtGenomeNode **)gt_array_pop(introns); gt_genome_node_delete(intron); } gt_array_delete(introns); while(gt_array_size(gaps) > 0) { gap = *(GtGenomeNode **)gt_array_pop(gaps); gt_genome_node_delete(gap); } gt_array_delete(gaps); gt_str_delete(seqid); }
bool gth_sa_exons_are_forward_and_consecutive(const GthSA *sa) { GtArray *ranges; gt_assert(sa); ranges = gt_array_new(sizeof (GtRange)); gth_sa_get_exons(sa, ranges); if (!gt_ranges_are_consecutive(ranges)) { gt_array_delete(ranges); return false; } gt_array_delete(ranges); return true; }
void gth_sa_delete(GthSA *sa) { if (!sa) return; gth_backtrace_path_delete(sa->backtrace_path); gt_array_delete(sa->exons); gt_array_delete(sa->introns); gt_str_delete(sa->gen_id); gt_str_delete(sa->ref_id); gt_str_delete(sa->gen_md5); gt_str_delete(sa->ref_md5); gt_str_delete(sa->gen_desc); gt_str_delete(sa->ref_desc); gt_str_delete(sa->gff3_target_attribute); gt_free(sa); }
void agn_bron_kerbosch( GtArray *R, GtArray *P, GtArray *X, GtArray *cliques, bool skipsimplecliques ) { gt_assert(R != NULL && P != NULL && X != NULL && cliques != NULL); if(gt_array_size(P) == 0 && gt_array_size(X) == 0) { if(skipsimplecliques == false || gt_array_size(R) != 1) { GtUword i; AgnTranscriptClique *clique = agn_transcript_clique_new(); for(i = 0; i < gt_array_size(R); i++) { GtFeatureNode *transcript = *(GtFeatureNode **)gt_array_get(R, i); agn_transcript_clique_add(clique, transcript); } gt_array_add(cliques, clique); } } while(gt_array_size(P) > 0) { GtGenomeNode *v = *(GtGenomeNode **)gt_array_get(P, 0); // newR = R \union {v} GtArray *newR = agn_gt_array_copy(R, sizeof(GtGenomeNode *)); gt_array_add(newR, v); // newP = P \intersect N(v) GtArray *newP = agn_feature_neighbors(v, P); // newX = X \intersect N(v) GtArray *newX = agn_feature_neighbors(v, X); // Recursive call // agn_bron_kerbosch(R \union {v}, P \intersect N(v), X \intersect N(X)) agn_bron_kerbosch(newR, newP, newX, cliques, skipsimplecliques); // Delete temporary arrays just created gt_array_delete(newR); gt_array_delete(newP); gt_array_delete(newX); // P := P \ {v} gt_array_rem(P, 0); // X := X \union {v} gt_array_add(X, v); } }
static void infer_cds_visitor_test_data(GtQueue *queue) { GtError *error = gt_error_new(); const char *file = "data/gff3/grape-codons.gff3"; GtNodeStream *gff3in = gt_gff3_in_stream_new_unsorted(1, &file); gt_gff3_in_stream_check_id_attributes((GtGFF3InStream *)gff3in); gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream *)gff3in); GtLogger *logger = gt_logger_new(true, "", stderr); GtNodeStream *icv_stream = agn_infer_cds_stream_new(gff3in, NULL, logger); GtArray *feats = gt_array_new( sizeof(GtFeatureNode *) ); GtNodeStream *arraystream = gt_array_out_stream_new(icv_stream, feats, error); int pullresult = gt_node_stream_pull(arraystream, error); if(pullresult == -1) { fprintf(stderr, "[AgnInferCDSVisitor::infer_cds_visitor_test_data] error " "processing features: %s\n", gt_error_get(error)); } gt_node_stream_delete(gff3in); gt_node_stream_delete(icv_stream); gt_node_stream_delete(arraystream); gt_logger_delete(logger); gt_array_sort(feats, (GtCompare)agn_genome_node_compare); gt_array_reverse(feats); while(gt_array_size(feats) > 0) { GtFeatureNode *fn = *(GtFeatureNode **)gt_array_pop(feats); gt_queue_add(queue, fn); } gt_array_delete(feats); gt_error_delete(error); }
static int feature_index_lua_get_features_for_range(lua_State *L) { GtFeatureIndex **feature_index; const char *seqid; GtRange *range; GtError *err; bool has_seqid; GtArray *features; GT_UNUSED int had_err; feature_index = check_feature_index(L, 1); seqid = luaL_checkstring(L, 2); err = gt_error_new(); if (gt_feature_index_has_seqid(*feature_index, &has_seqid, seqid, err)) return gt_lua_error(L, err); gt_error_delete(err); luaL_argcheck(L, has_seqid, 2, "feature_index does not contain seqid"); range = check_range(L, 3); features = gt_array_new(sizeof (GtGenomeNode*)); err = gt_error_new(); had_err = gt_feature_index_get_features_for_range(*feature_index, features, seqid, range, err); if (had_err) return gt_lua_error(L, err); gt_error_delete(err); push_features_as_table(L, features); gt_array_delete(features); return 1; }
void gt_splicedseq_delete(Splicedseq *ss) { if (!ss) return; gt_str_delete(ss->splicedseq); gt_array_delete(ss->positionmapping); gt_free(ss); }
void gt_diagram_delete(GtDiagram *diagram) { if (!diagram) return; gt_rwlock_wrlock(diagram->lock); gt_array_delete(diagram->features); if (diagram->blocks) gt_hashmap_delete(diagram->blocks); gt_hashmap_delete(diagram->nodeinfo); gt_hashmap_delete(diagram->collapsingtypes); gt_hashmap_delete(diagram->groupedtypes); gt_hashmap_delete(diagram->caption_display_status); gt_array_delete(diagram->custom_tracks); gt_rwlock_unlock(diagram->lock); gt_rwlock_delete(diagram->lock); gt_free(diagram); }
void gt_tool_iterator_delete(GtToolIterator *tool_iterator) { if (!tool_iterator) return; gt_array_delete(tool_iterator->tool_stack); gt_str_delete(tool_iterator->prefixptr); gt_free(tool_iterator); }
static void split_cds_feature(GtFeatureNode *cds_feature, GtFeatureNode *fn) { GtArray *parents; unsigned long i; gt_assert(cds_feature && fn); /* find parents */ parents = find_cds_parents(cds_feature, fn); /* remove CDS feature */ gt_feature_node_remove_leaf(fn, cds_feature); /* add CDS feature to all parents */ for (i = 0; i < gt_array_size(parents); i++) { GtFeatureNode *parent = *(GtFeatureNode**) gt_array_get(parents, i); const char *id = gt_feature_node_get_attribute(parent, GT_GFF_ID); if (!i) { gt_feature_node_set_attribute(cds_feature, GT_GFF_PARENT, id); gt_feature_node_add_child(parent, cds_feature); } else { GtFeatureNode *new_cds = gt_feature_node_clone(cds_feature); gt_feature_node_set_attribute(new_cds, GT_GFF_PARENT, id); gt_feature_node_add_child(parent, new_cds); gt_genome_node_delete((GtGenomeNode*) cds_feature); } } gt_array_delete(parents); }
static void potentialintronspostpro(GtArray *intronstoprocess, unsigned long icdelta, unsigned long icminremintronlength) { GtArray *originalintrons; GtRange potintron; unsigned long i, potintronlength, minintronlength = 2 * icdelta + icminremintronlength; originalintrons = gt_array_new(sizeof (GtRange)); /* save all (potential) introns */ gt_array_add_array(originalintrons, intronstoprocess); /* reset introns to process */ gt_array_set_size(intronstoprocess, 0); /* store introns */ for (i = 0; i < gt_array_size(originalintrons); i++) { potintron = *(GtRange*) gt_array_get(originalintrons, i); potintronlength = potintron.end - potintron.start + 1; if (potintronlength >= minintronlength) { /* keep this intron (plus/minus intron deltas) that is, this intron is cut out later */ potintron.start += icdelta; potintron.end -= icdelta; gt_array_add(intronstoprocess, potintron); } /* else: skip this intron that is, this intron is not cut out later */ } gt_array_delete(originalintrons); }
void gt_feature_node_iterator_delete(GtFeatureNodeIterator *fni) { if (!fni) return; gt_genome_node_delete((GtGenomeNode*) fni->fn); gt_array_delete(fni->feature_stack); gt_free(fni); }
int gt_feature_index_add_gff3file(GtFeatureIndex *feature_index, const char *gff3file, GtError *err) { GtNodeStream *gff3_in_stream; GtGenomeNode *gn; GtArray *tmp; int had_err = 0; GtUword i; gt_error_check(err); gt_assert(feature_index && gff3file); tmp = gt_array_new(sizeof (GtGenomeNode*)); gff3_in_stream = gt_gff3_in_stream_new_unsorted(1, &gff3file); while (!(had_err = gt_node_stream_next(gff3_in_stream, &gn, err)) && gn) gt_array_add(tmp, gn); if (!had_err) { GtNodeVisitor *feature_visitor = gt_feature_visitor_new(feature_index); for (i=0;i<gt_array_size(tmp);i++) { gn = *(GtGenomeNode**) gt_array_get(tmp, i); /* no need to lock, add_*_node() is synchronized */ had_err = gt_genome_node_accept(gn, feature_visitor, NULL); gt_assert(!had_err); /* cannot happen */ } gt_node_visitor_delete(feature_visitor); } gt_node_stream_delete(gff3_in_stream); for (i=0;i<gt_array_size(tmp);i++) gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(tmp, i)); gt_array_delete(tmp); return had_err; }
static void findmaximalscores_withoverlaps(GtChain *chain, GtChaininfo *chaininfo, GtFragment *fragments, unsigned long num_of_fragments, unsigned long max_gap_width, unsigned long seqlen1, double mincoverage, GtChainProc chainprocessor, void *cpinfo, Overlapinfo *overlapinfo) { unsigned long i, startfrag; GtArray *startfragments; gt_assert(seqlen1 != GT_UNDEF_ULONG); gt_assert(mincoverage != GT_UNDEF_DOUBLE); startfragments = gt_array_new(sizeof (unsigned long)); /* compute chain array */ for (i = 0; i < num_of_fragments; i++) { if (overlapinfo[i].active) { /* current fragment is active */ if (overlapinfo[overlapinfo[i].startofchain].chainarray == UNDEFPREVIOUS) { if (((double) overlapinfo[i].dim1lengthofchain / (double) seqlen1) >= mincoverage) { /* no other fragment has the same start fragment yet and coverage is high enough -> store end fragment */ overlapinfo[overlapinfo[i].startofchain].chainarray = i; /* since this is the first time, store start fragment number to avoid additional scan of all fragments below */ gt_array_add(startfragments, overlapinfo[i].startofchain); } } else if (overlapinfo[i].dim1lengthofchain > overlapinfo[overlapinfo[overlapinfo[i].startofchain].chainarray] .dim1lengthofchain) { /* coverage is higher then coverage of earlier start fragment -> update end fragment */ overlapinfo[overlapinfo[i].startofchain].chainarray = i; } } } /* retrieve maximal chains */ for (i = 0; i < gt_array_size(startfragments); i++) { startfrag = *(unsigned long*) gt_array_get(startfragments, i); gt_assert(overlapinfo[startfrag].chainarray != UNDEFPREVIOUS); gt_chain_reset(chain); gt_chain_set_score(chain, chaininfo[overlapinfo[startfrag].chainarray].score); retracepreviousinchain(chain, chaininfo, num_of_fragments, overlapinfo[startfrag].chainarray); chainprocessor(chain, fragments, num_of_fragments, max_gap_width, cpinfo); } gt_array_delete(startfragments); }
static int gt_ltrdigest_pdom_visitor_attach_hit(GtLTRdigestPdomVisitor *lv, GtHMMERModelHit *modelhit, GtHMMERSingleHit *singlehit) { GT_UNUSED GtUword i; GtGenomeNode *gf; int had_err = 0; GtRange rrng; gt_assert(lv && singlehit); rrng = gt_ltrdigest_pdom_visitor_coords(lv, singlehit); if (gt_array_size(singlehit->chains) > 0 || lv->output_all_chains) { char buf[32]; gf = gt_feature_node_new(gt_genome_node_get_seqid((GtGenomeNode*) lv->ltr_retrotrans), gt_ft_protein_match, rrng.start, rrng.end, singlehit->strand); gt_genome_node_add_user_data((GtGenomeNode*) gf, "pdom_alignment", gt_str_ref(singlehit->alignment), (GtFree) gt_str_delete); gt_genome_node_add_user_data((GtGenomeNode*) gf, "pdom_aaseq", gt_str_ref(singlehit->aastring), (GtFree) gt_str_delete); gt_feature_node_set_source((GtFeatureNode*) gf, lv->tag); gt_feature_node_set_score((GtFeatureNode*) gf, (float) singlehit->evalue); (void) snprintf(buf, (size_t) 32, "%d", (int) singlehit->frame); gt_feature_node_add_attribute((GtFeatureNode*) gf, "reading_frame", buf); if (modelhit->modelname != NULL) { gt_feature_node_add_attribute((GtFeatureNode*) gf, "name", modelhit->modelname); } if (gt_array_size(singlehit->chains) > 1UL && lv->output_all_chains) { GtStr *buffer; GtUword j; gt_assert(singlehit->chains != NULL); buffer = gt_str_new(); for (j = 0UL; j < gt_array_size(singlehit->chains); j++) { gt_str_append_cstr(buffer, modelhit->modelname); gt_str_append_char(buffer, ':'); gt_str_append_ulong(buffer, *(GtUword*) gt_array_get(singlehit->chains, j)); if (j != gt_array_size(singlehit->chains) - 1) { gt_str_append_char(buffer, ','); } } gt_feature_node_set_attribute((GtFeatureNode*) gf, "chains", gt_str_get(buffer)); gt_str_delete(buffer); } gt_feature_node_add_child(lv->ltr_retrotrans, (GtFeatureNode*) gf); } gt_array_delete(singlehit->chains); singlehit->chains = NULL; return had_err; }
static int m2i_change_target_seqids(GtFeatureNode *fn, const char *target, GtRegionMapping *region_mapping, GtError *err) { GtStrArray *target_ids; GtArray *target_ranges, *target_strands; GtStr *desc, *new_seqid; unsigned long i; int had_err; gt_error_check(err); gt_assert(fn && target && region_mapping); target_ids = gt_str_array_new(); target_ranges = gt_array_new(sizeof (GtRange)); target_strands = gt_array_new(sizeof (GtStrand)); desc = gt_str_new(); new_seqid = gt_str_new(); had_err = gt_gff3_parser_parse_all_target_attributes(target, false, target_ids, target_ranges, target_strands, "", 0, err); for (i = 0; !had_err && i < gt_str_array_size(target_ids); i++) { GtStr *seqid; gt_str_reset(desc); gt_str_reset(new_seqid); seqid = gt_str_array_get_str(target_ids, i); had_err = gt_region_mapping_get_description(region_mapping, desc, seqid, err); if (!had_err) gt_regular_seqid_save(new_seqid, desc); gt_str_array_set(target_ids, i, new_seqid); } if (!had_err) { GtStr *new_target = gt_str_new(); gt_gff3_parser_build_target_str(new_target, target_ids, target_ranges, target_strands); gt_feature_node_set_attribute(fn, GT_GFF_TARGET, gt_str_get(new_target)); gt_str_delete(new_target); } gt_str_delete(new_seqid); gt_str_delete(desc); gt_array_delete(target_strands); gt_array_delete(target_ranges); gt_str_array_delete(target_ids); return had_err; }
static void gff3_numsorted_out_stream_free(GtNodeStream *ns) { GtGFF3NumsortedOutStream *gff3_out_stream = gff3_numsorted_out_stream_cast(ns); gt_node_stream_delete(gff3_out_stream->in_stream); gt_node_visitor_delete(gff3_out_stream->gff3_visitor); gt_array_delete(gff3_out_stream->buffer); gt_queue_delete(gff3_out_stream->outqueue); }
void gth_pgl_collection_delete(GthPGLCollection *pgl_collection) { GtUword i; if (!pgl_collection) return; for (i = 0; i < gt_array_size(pgl_collection->pgls); i++) gth_pgl_delete(*(GthPGL**) gt_array_get(pgl_collection->pgls, i)); gt_array_delete(pgl_collection->pgls); gt_free(pgl_collection); }
void gt_class_alloc_clean(void) { GtUword i; if (!c_classes) return; for (i = 0; i < gt_array_size(c_classes); i++) gt_free(*(void**) gt_array_get(c_classes, i)); gt_array_delete(c_classes); c_classes = NULL; }
void gt_clustered_set_union_find_delete(GtClusteredSet *cs, GT_UNUSED GtError *err) { if (!cs) return; GtClusteredSetUF *cs_uf = (GtClusteredSetUF*) cs; gt_free(cs_uf->cluster_elems); gt_array_delete(cs_uf->cluster_info); gt_bittab_delete(cs_uf->in_cluster); }
void gt_layout_delete(GtLayout *layout) { if (!layout) return; if (layout->twc && layout->own_twc) gt_text_width_calculator_delete(layout->twc); gt_hashmap_delete(layout->tracks); gt_array_delete(layout->custom_tracks); gt_free(layout); }
static void gv_test_calc_integrity(AgnUnitTest *test) { const char *filename = "data/gff3/gaeval-stream-unit-test-2.gff3"; GtNodeStream *align_in = gt_gff3_in_stream_new_unsorted(1, &filename); AgnGaevalParams params = { 0.6, 0.3, 0.05, 0.05, 400, 200, 100 }; GtNodeVisitor *nv = agn_gaeval_visitor_new(align_in, params); AgnGaevalVisitor *gv = gaeval_visitor_cast(nv); gt_node_stream_delete(align_in); GtNodeStream *gff3in = gt_gff3_in_stream_new_unsorted(1, &filename); GtHashmap *typestokeep = gt_hashmap_new(GT_HASH_STRING, NULL, NULL); gt_hashmap_add(typestokeep, "mRNA", "mRNA"); GtNodeStream *filtstream = agn_filter_stream_new(gff3in, typestokeep); GtLogger *logger = gt_logger_new(true, "", stderr); GtNodeStream *ics = agn_infer_cds_stream_new(filtstream, NULL, logger); GtNodeStream *ies = agn_infer_exons_stream_new(ics, NULL, logger); GtError *error = gt_error_new(); GtArray *feats = gt_array_new( sizeof(GtFeatureNode *) ); GtNodeStream *featstream = gt_array_out_stream_new(ies, feats, error); int result = gt_node_stream_pull(featstream, error); if(result == -1) { fprintf(stderr, "[AgnGaevalVisitor::gv_test_calc_integrity] error " "processing GFF3: %s\n", gt_error_get(error)); return; } gt_node_stream_delete(gff3in); gt_node_stream_delete(filtstream); gt_node_stream_delete(featstream); gt_node_stream_delete(ics); gt_node_stream_delete(ies); gt_logger_delete(logger); gt_hashmap_delete(typestokeep); agn_assert(gt_array_size(feats) == 2); GtFeatureNode *g1 = *(GtFeatureNode **)gt_array_get(feats, 0); GtFeatureNode *g2 = *(GtFeatureNode **)gt_array_get(feats, 1); double cov1 = gaeval_visitor_calculate_coverage(gv, g1, error); double cov2 = gaeval_visitor_calculate_coverage(gv, g2, error); double int1 = gaeval_visitor_calculate_integrity(gv, g1, cov1, NULL, error); double int2 = gaeval_visitor_calculate_integrity(gv, g2, cov2, NULL, error); bool test1 = fabs(cov1 - 1.000) < 0.001 && fabs(cov2 - 0.997) < 0.001 && fabs(int1 - 0.850) < 0.001 && fabs(int2 - 0.863) < 0.001; agn_unit_test_result(test, "calculate integrity", test1); gt_error_delete(error); gt_array_delete(feats); gt_genome_node_delete((GtGenomeNode *)g1); gt_genome_node_delete((GtGenomeNode *)g2); gt_node_visitor_delete(nv); }
static void blocklist_delete(void *value) { GtUword i; GtArray *a; if (!value) return; a = (GtArray*) value; for (i = 0; i < gt_array_size(a); i++) gt_block_delete(*(GtBlock**) gt_array_get(a, i)); gt_array_delete(a); }
static int infer_cds_visitor_visit_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn, GtError *error) { AgnInferCDSVisitor *v = infer_cds_visitor_cast(nv); gt_error_check(error); GtFeatureNodeIterator *iter = gt_feature_node_iterator_new(fn); GtFeatureNode *current; for(current = gt_feature_node_iterator_next(iter); current != NULL; current = gt_feature_node_iterator_next(iter)) { if(!agn_typecheck_mrna(current)) continue; v->cds = agn_typecheck_select(current, agn_typecheck_cds); v->utrs = agn_typecheck_select(current, agn_typecheck_utr); v->exons = agn_typecheck_select(current, agn_typecheck_exon); v->starts = agn_typecheck_select(current, agn_typecheck_start_codon); v->stops = agn_typecheck_select(current, agn_typecheck_stop_codon); v->mrna = current; infer_cds_visitor_infer_cds(v); infer_cds_visitor_check_start(v); infer_cds_visitor_check_stop(v); infer_cds_visitor_infer_utrs(v); infer_cds_visitor_check_cds_multi(v); infer_cds_visitor_check_cds_phase(v); infer_cds_visitor_set_utrs(v); v->mrna = NULL; gt_array_delete(v->cds); gt_array_delete(v->utrs); gt_array_delete(v->exons); gt_array_delete(v->starts); gt_array_delete(v->stops); } gt_feature_node_iterator_delete(iter); return 0; }