void gt_score_matrix_delete(GtScoreMatrix *sm) { if (!sm) return; gt_alphabet_delete(sm->alphabet); gt_array2dim_delete(sm->scores); gt_free(sm); }
void gt_encseq_metadata_delete(GtEncseqMetadata *emd) { if (emd == NULL) return; if (emd->alpha != NULL) gt_alphabet_delete(emd->alpha); gt_free(emd); }
static int alphabet_lua_delete(lua_State *L) { GtAlphabet **alpha; alpha = check_alphabet(L, 1); gt_alphabet_delete(*alpha); return 0; }
static int gt_compreads_compress_runner(GT_UNUSED int argc, GT_UNUSED const char **argv, GT_UNUSED int parsed_args, void *tool_arguments, GtError *err) { GtCsrHcrEncodeArguments *arguments = tool_arguments; int had_err = 0; GtAlphabet *alpha = NULL; GtHcrEncoder *hcre = NULL; GtTimer *timer = NULL; gt_error_check(err); gt_assert(arguments); if (gt_showtime_enabled()) { timer = gt_timer_new_with_progress_description("start"); gt_timer_start(timer); gt_assert(timer); } if (gt_str_length(arguments->smap) > 0) { alpha = gt_alphabet_new_from_file_no_suffix(gt_str_get(arguments->smap), err); if (!alpha) had_err = 1; } else { alpha = gt_alphabet_new_dna(); if (!alpha) had_err = 1; } if (!had_err) { if (timer != NULL) gt_timer_show_progress(timer, "encoding", stdout); hcre = gt_hcr_encoder_new(arguments->files, alpha, arguments->descs, arguments->qrng, timer, err); if (!hcre) had_err = 1; else { if (arguments->pagewise) gt_hcr_encoder_set_sampling_page(hcre); else if (arguments->regular) gt_hcr_encoder_set_sampling_regular(hcre); gt_hcr_encoder_set_sampling_rate(hcre, arguments->srate); if (gt_hcr_encoder_encode(hcre, gt_str_get(arguments->name), timer, err) != 0) had_err = 1; } gt_hcr_encoder_delete(hcre); } gt_alphabet_delete(alpha); if (timer != NULL) { gt_timer_show_progress_final(timer, stdout); gt_timer_delete(timer); } return had_err; }
void gt_samfile_iterator_delete(GtSamfileIterator *s_iter) { if (!s_iter) return; samclose(s_iter->samfile); if (s_iter->current_alignment) gt_sam_alignment_delete(s_iter->current_alignment); gt_alphabet_delete(s_iter->alphabet); gt_free(s_iter); }
static void gt_wtree_encseq_delete(GT_UNUSED GtWtree *wtree) { if (wtree != NULL) { GtWtreeEncseq *wtree_encseq = gt_wtree_encseq_cast(wtree); gt_encseq_delete(wtree_encseq->encseq); gt_alphabet_delete(wtree_encseq->alpha); gt_free(wtree_encseq->bits); gt_compressed_bitsequence_delete(wtree_encseq->c_bits); } }
void gt_sam_alignment_delete(GtSamAlignment *sam_alignment) { if (sam_alignment != NULL) { bam_destroy1(sam_alignment->s_alignment); gt_alphabet_delete(sam_alignment->alphabet); gt_free(sam_alignment->qual_buffer); gt_free(sam_alignment->seq_buffer); gt_free(sam_alignment); } }
int gt_codon_iterator_encseq_unit_test(GtError *err) { int had_err = 0, i, j; const char *testseq = "gctgatcgactgaacatagctagcacggccgcgcgatcgtacgatg", *testseq_rc = "catcgtacgatcgcgcggccgtgctagctatgttcagtcgatcagc", *testseq_rv = "gtagcatgctagcgcgccggcacgatcgatacaagtcagctagtcg", *testseq_cm = "cgactagctgacttgtatcgatcgtgccggcgcgctagcatgctac"; GtEncseq *encseq; GtEncseqBuilder *eb; GtCodonIterator *ci; GtAlphabet *alpha; char n1, n2, n3; unsigned int frame; gt_error_check(err); alpha = gt_alphabet_new_dna(); eb = gt_encseq_builder_new(alpha); gt_encseq_builder_add_cstr(eb, testseq, strlen(testseq), "foo"); encseq = gt_encseq_builder_build(eb, NULL); /* forward tests */ had_err = gt_codon_iterator_encseq_single_test(encseq, testseq, testseq, GT_READMODE_FORWARD, err); /* complement tests */ had_err = gt_codon_iterator_encseq_single_test(encseq, testseq, testseq_cm, GT_READMODE_COMPL, err); /* revcompl tests */ had_err = gt_codon_iterator_encseq_single_test(encseq, testseq, testseq_rc, GT_READMODE_REVCOMPL, err); /* reverse tests */ had_err = gt_codon_iterator_encseq_single_test(encseq, testseq, testseq_rv, GT_READMODE_REVERSE, err); /* lengths < 3 */ for (j = 0; !had_err && j < 3; j++) { ci = gt_codon_iterator_encseq_new_with_readmode(encseq, 10, j, GT_READMODE_REVCOMPL, NULL); i = 10; while (!(gt_codon_iterator_next(ci, &n1, &n2, &n3, &frame, NULL))) { gt_ensure(had_err, false); } gt_ensure(had_err, i == 10); gt_codon_iterator_delete(ci); } gt_encseq_delete(encseq); gt_encseq_builder_delete(eb); gt_alphabet_delete(alpha); return had_err; }
void gt_seq_delete(GtSeq *s) { if (!s) return; if (s->own_seq) gt_free(s->seq); if (s->own_description) gt_free(s->description); gt_free(s->encoded_seq); gt_alphabet_delete(s->seqalpha); gt_free(s); }
void gt_freefmindex(Fmindex *fmindex) { if (fmindex->mappedptr != NULL) { gt_fa_xmunmap(fmindex->mappedptr); } if (fmindex->bwtformatching != NULL) { gt_encseq_delete(fmindex->bwtformatching); fmindex->bwtformatching = NULL; } gt_alphabet_delete((GtAlphabet *) fmindex->alphabet); }
int gt_alphabet_unit_test(GtError *err) { int had_err = 0; GtAlphabet *a, *b, *c; gt_error_check(err); a = gt_alphabet_new_dna(); b = gt_alphabet_new_protein(); c = gt_alphabet_clone(a); gt_ensure(had_err, gt_alphabet_equals(a, a)); gt_ensure(had_err, gt_alphabet_equals(b, b)); gt_ensure(had_err, gt_alphabet_equals(c, c)); gt_ensure(had_err, !gt_alphabet_equals(a, b)); gt_ensure(had_err, gt_alphabet_equals(a, c)); gt_alphabet_delete(a); gt_alphabet_delete(b); gt_alphabet_delete(c); return had_err; }
GtAlphabet* gt_alphabet_new_from_file_no_suffix(const char *filename, GtError *err) { GtStr *transpath = NULL; bool haserr = false; GtAlphabet *alpha; gt_assert(filename); gt_error_check(err); alpha = gt_alphabet_new_empty(); if (!gt_file_exists(filename)) { GtStr *prog; const char *progname = gt_error_get_progname(err); gt_assert(progname != NULL); prog = gt_str_new(); gt_str_append_cstr_nt(prog, progname, gt_cstr_length_up_to_char(progname, ' ')); transpath = gt_get_gtdata_path(gt_str_get(prog), err); gt_str_delete(prog); gt_str_append_cstr(transpath, "/trans/"); gt_str_append_cstr(transpath, filename); } if (read_symbolmap(alpha, transpath == NULL ? filename : gt_str_get(transpath), err) != 0) { haserr = true; } gt_str_delete(transpath); if (alpha == NULL) { haserr = true; } if (haserr) { gt_alphabet_delete((GtAlphabet*) alpha); return NULL; } return alpha; }
GtAlphabet* gt_alphabet_new_from_sequence(const GtStrArray *filenametab, GtError *err) { GtAlphabet *alpha; int had_err = 0; gt_error_check(err); alpha = gt_alphabet_new_empty(); if (assign_protein_or_dna_alphabet(alpha,filenametab,err) != 0) { had_err = -1; gt_assert(gt_error_is_set(err)); } if (had_err) { gt_alphabet_delete(alpha); return NULL; } return alpha; }
int gt_ltrdigest_arguments_check(GT_UNUSED int rest_argc, void *tool_arguments, GtError* err) { GtLTRdigestOptions *arguments = tool_arguments; int had_err = 0; if (arguments->nthreads > 0) { gt_warning("The '-threads' option is deprecated. Please use the '-j'" "option of the 'gt' call instead, e.g.:\n" " gt -j %lu ltrdigest ...", arguments->nthreads); } /* -trnas */ if (!had_err && arguments->trna_lib && gt_str_length(arguments->trna_lib) > 0) { if (!gt_file_exists(gt_str_get(arguments->trna_lib))) { gt_error_set(err, "File '%s' does not exist!", gt_str_get(arguments->trna_lib)); had_err = -1; } } if (!had_err) { GtHMM *hmm; GtAlphabet *alpha; alpha = gt_alphabet_new_dna(); hmm = gt_ppt_hmm_new(alpha, &arguments->ppt_opts); if (!hmm) { gt_error_set(err, "PPT HMM parameters are not valid!"); had_err = -1; } else gt_hmm_delete(hmm); gt_alphabet_delete(alpha); } return had_err; }
GtScoreMatrix* gt_score_matrix_new_read_protein(const char *path, GtError *err) { GtAlphabet *protein_alpha; GtScoreMatrix *sm; int had_err; gt_error_check(err); gt_assert(path); /* create score matrix */ protein_alpha = gt_alphabet_new_protein(); sm = gt_score_matrix_new(protein_alpha); gt_alphabet_delete(protein_alpha); /* parse matrix file */ had_err = parse_score_matrix(sm, path, err); if (had_err) { gt_score_matrix_delete(sm); return NULL; } return sm; }
void gt_condenseq_delete(GtCondenseq *condenseq) { if (condenseq != NULL) { GtUword i; for (i = 0; i < condenseq->ldb_nelems; i++) { gt_editscript_delete(condenseq->links[i].editscript); } for (i = 0; i < condenseq->udb_nelems; i++) { GT_FREEARRAY(&(condenseq->uniques[i].links), uint32_t); } gt_alphabet_delete(condenseq->alphabet); gt_encseq_delete(condenseq->unique_es); gt_free(condenseq->buffer); gt_free(condenseq->filename); gt_free(condenseq->links); gt_free(condenseq->orig_ids); gt_free(condenseq->ubuffer); gt_free(condenseq->uniques); gt_intset_delete(condenseq->sdstab); gt_intset_delete(condenseq->ssptab); gt_free(condenseq); } }
static int gt_compreads_decompress_runner(GT_UNUSED int argc, GT_UNUSED const char **argv, GT_UNUSED int parsed_args, void *tool_arguments, GtError *err) { GtCsrHcrDecodeArguments *arguments = tool_arguments; int had_err = 0; GtAlphabet *alpha = NULL; GtHcrDecoder *hcrd = NULL; GtTimer *timer = NULL; unsigned long start, end; gt_error_check(err); gt_assert(arguments); if (gt_showtime_enabled()) { timer = gt_timer_new_with_progress_description("start"); gt_timer_start(timer); gt_assert(timer); } if (gt_str_length(arguments->smap) > 0) { alpha = gt_alphabet_new_from_file_no_suffix(gt_str_get(arguments->smap), err); if (!alpha) had_err = -1; } else { alpha = gt_alphabet_new_dna(); if (!alpha) had_err = -1; } if (!had_err) { if (timer != NULL) gt_timer_show_progress(timer, "decoding", stdout); if (gt_str_length(arguments->name) == 0) { char *basenameptr; basenameptr = gt_basename(gt_str_get(arguments->file)); gt_str_set(arguments->name, basenameptr); gt_free(basenameptr); } hcrd = gt_hcr_decoder_new(gt_str_get(arguments->file), alpha, arguments->descs, timer, err); if (hcrd == NULL) had_err = -1; else { if (arguments->bench != 0) { had_err = gt_compreads_decompress_benchmark(hcrd, arguments->bench, timer, err); } else { if (arguments->rng.start != GT_UNDEF_ULONG && arguments->rng.end != GT_UNDEF_ULONG) { if (arguments->rng.start >= gt_hcr_decoder_num_of_reads(hcrd) || arguments->rng.end >= gt_hcr_decoder_num_of_reads(hcrd)) { gt_error_set(err, "range %lu-%lu includes a read number exceeding " "the total number of reads (%lu)", arguments->rng.start, arguments->rng.end, gt_hcr_decoder_num_of_reads(hcrd)); had_err = -1; } start = arguments->rng.start; end = arguments->rng.end; } else { start = 0; end = gt_hcr_decoder_num_of_reads(hcrd) - 1; } if (!had_err) { gt_log_log("filebasename: %s", gt_str_get(arguments->name)); if (gt_hcr_decoder_decode_range(hcrd, gt_str_get(arguments->name), start, end, timer, err) != 0) had_err = -1; } } } gt_hcr_decoder_delete(hcrd); } gt_alphabet_delete(alpha); if (timer != NULL) { gt_timer_show_progress_final(timer, stdout); gt_timer_delete(timer); } if (had_err) gt_assert(gt_error_is_set(err)); return had_err; }
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; }
static int gt_linspace_align_runner(GT_UNUSED int argc, GT_UNUSED const char **argv, GT_UNUSED int parsed_args, void *tool_arguments, GtError *err) { GtLinspaceArguments *arguments = tool_arguments; int had_err = 0; GtAlignment *align; GtWord left_dist = 0, right_dist = 0; GtSequenceTable *sequence_table1, *sequence_table2; GtLinspaceManagement *spacemanager; GtScoreHandler *scorehandler = NULL; GtTimer *linspacetimer = NULL; GtAlphabet *alphabet = NULL; gt_error_check(err); gt_assert(arguments); sequence_table1 = gt_sequence_table_new(); sequence_table2 = gt_sequence_table_new(); align = gt_alignment_new(); spacemanager = gt_linspace_management_new(); gt_linspace_management_set_TSfactor(spacemanager,arguments->timesquarefactor); /* get sequences */ if (gt_str_array_size(arguments->strings) > 0) { get_onesequence(sequence_table1, arguments->strings, 0); sequence_table1->size++; get_onesequence(sequence_table2, arguments->strings, 1); sequence_table2->size++; } else if (gt_str_array_size(arguments->files) > 0) { had_err = get_fastasequences(sequence_table1, gt_str_array_get_str(arguments->files,0),err); if (!had_err) { had_err = get_fastasequences(sequence_table2, gt_str_array_get_str(arguments->files,1),err); } } if (arguments->dna) { alphabet = gt_alphabet_new_dna(); } else { gt_assert(arguments->protein); alphabet = gt_alphabet_new_protein(); } gt_encode_sequence_table(alphabet,sequence_table1); gt_encode_sequence_table(alphabet,sequence_table2); if (!had_err) { scorehandler = gt_arguments2scorehandler(arguments,err); if (scorehandler == NULL) { had_err = -1; } else { if (arguments->global && arguments->protein && !arguments->has_costmatrix) { GtScoreHandler *costhandler = gt_scorehandler2costhandler(scorehandler); gt_scorehandler_delete(scorehandler); scorehandler = costhandler; } } } /* get diagonal band */ if (!had_err && arguments->diagonal) { if (gt_str_array_size(arguments->diagonalbonds) > 0) { had_err = gt_parse_score_value(__LINE__,&left_dist, gt_str_array_get(arguments->diagonalbonds,0), false, err); if (!had_err) { had_err = gt_parse_score_value(__LINE__,&right_dist, gt_str_array_get(arguments->diagonalbonds,1), false, err); } } } if (!had_err && arguments->spacetime) { linspacetimer = gt_timer_new(); } /* alignment functions with linear gap costs */ if (!had_err) { bool affine; if (gt_str_array_size(arguments->linearcosts) > 0) { affine = false; } else { gt_assert(gt_str_array_size(arguments->affinecosts) > 0); affine = true; } had_err = gt_all_against_all_alignment_check ( affine, align, arguments, spacemanager, scorehandler, gt_alphabet_characters(alphabet), gt_alphabet_wildcard_show(alphabet), sequence_table1, sequence_table2, left_dist, right_dist, linspacetimer,err); } /*spacetime option*/ if (!had_err && arguments->spacetime) { printf("# combined space peak in kilobytes: %f\n", GT_KILOBYTES(gt_linspace_management_get_spacepeak(spacemanager))); gt_timer_show_formatted(linspacetimer,"# TIME overall " GT_WD ".%02ld\n", stdout); } gt_timer_delete(linspacetimer); gt_linspace_management_delete(spacemanager); gt_sequence_table_delete(sequence_table1); gt_sequence_table_delete(sequence_table2); gt_alignment_delete(align); gt_alphabet_delete(alphabet); gt_scorehandler_delete(scorehandler); return had_err; }
void gt_tyrsearchinfo_delete(Tyrsearchinfo *tyrsearchinfo) { gt_alphabet_delete(tyrsearchinfo->dnaalpha); FREESPACE(tyrsearchinfo->bytecode); FREESPACE(tyrsearchinfo->rcbuf); }
GtPBSResults* gt_pbs_find(const char *seq, const char *rev_seq, GtLTRElement *element, GtPBSOptions *o, GtError *err) { GtSeq *seq_forward, *seq_rev; GtPBSResults *results; unsigned long j; GtAlignment *ali; GtAlphabet *a = gt_alphabet_new_dna(); GtScoreFunction *sf = gt_dna_scorefunc_new(a, o->ali_score_match, o->ali_score_mismatch, o->ali_score_insertion, o->ali_score_deletion); gt_assert(seq && rev_seq && sf && a && element); results = gt_pbs_results_new(element, o); seq_forward = gt_seq_new(seq + (gt_ltrelement_leftltrlen(element)) - (o->radius), 2*o->radius + 1, a); seq_rev = gt_seq_new(rev_seq + (gt_ltrelement_rightltrlen(element)) - (o->radius), 2*o->radius + 1, a); for (j=0;j<gt_bioseq_number_of_sequences(o->trna_lib);j++) { GtSeq *trna_seq, *trna_from3; char *trna_from3_full; unsigned long trna_seqlen; trna_seq = gt_bioseq_get_seq(o->trna_lib, j); trna_seqlen = gt_seq_length(trna_seq); trna_from3_full = gt_calloc(trna_seqlen, sizeof (char)); memcpy(trna_from3_full, gt_seq_get_orig(trna_seq), sizeof (char)*trna_seqlen); (void) gt_reverse_complement(trna_from3_full, trna_seqlen, err); trna_from3 = gt_seq_new_own(trna_from3_full, trna_seqlen, a); ali = gt_swalign(seq_forward, trna_from3, sf); gt_pbs_add_hit(results->hits, ali, o, trna_seqlen, gt_seq_get_description(trna_seq), GT_STRAND_FORWARD, results); gt_alignment_delete(ali); ali = gt_swalign(seq_rev, trna_from3, sf); gt_pbs_add_hit(results->hits, ali, o, trna_seqlen, gt_seq_get_description(trna_seq), GT_STRAND_REVERSE, results); gt_alignment_delete(ali); gt_seq_delete(trna_from3); } gt_seq_delete(seq_forward); gt_seq_delete(seq_rev); gt_score_function_delete(sf); gt_alphabet_delete(a); gt_array_sort(results->hits, gt_pbs_hit_compare); return results; }