void filelist_extend_errarr(FileList *flist, size_t len)
{
size_t i, oldcap = flist->errors_cap;
flist->errors_len = MAX2(flist->errors_len, len);
if(len > flist->errors_cap) {
flist->errors_cap = ROUNDUP2POW(len);
flist->errors = realloc(flist->errors, flist->errors_cap * sizeof(size_t));
for(i = oldcap; i < flist->errors_cap; i++) flist->errors[i] = 0;
}
}
alignment_t* alignment_create(size_t capacity)
{
capacity = ROUNDUP2POW(capacity);
alignment_t *result = malloc(sizeof(alignment_t));
result->result_a = malloc(sizeof(char)*capacity);
result->result_b = malloc(sizeof(char)*capacity);
result->capacity = capacity;
result->length = 0;
result->result_a[0] = result->result_b[0] = '\0';
result->pos_a = result->pos_b = result->len_a = result->len_b = 0;
result->score = 0;
return result;
}
static void _ensure_history_capacity(sw_history_t *hist, size_t arr_size)
{
if(arr_size > hist->hits_capacity) {
hist->hits_capacity = ROUNDUP2POW(arr_size);
bitset_set_length(&hist->match_scores_mask, hist->hits_capacity);
size_t mem = hist->hits_capacity * sizeof(*(hist->sorted_match_indices));
hist->sorted_match_indices = realloc(hist->sorted_match_indices, mem);
if(!hist->match_scores_mask.b || !hist->sorted_match_indices) {
fprintf(stderr, "%s:%i: Out of memory\n", __FILE__, __LINE__);
exit(EXIT_FAILURE);
}
}
}
void alignment_ensure_capacity(alignment_t* result, size_t strlength)
{
size_t capacity = strlength+1;
if(result->capacity < capacity)
{
capacity = ROUNDUP2POW(capacity);
result->result_a = realloc(result->result_a, sizeof(char)*capacity);
result->result_b = realloc(result->result_b, sizeof(char)*capacity);
result->capacity = capacity;
if(result->result_a == NULL || result->result_b == NULL) {
fprintf(stderr, "%s:%i: Out of memory\n", __FILE__, __LINE__);
exit(EXIT_FAILURE);
}
}
}
void filelist_mean_err(FileList *flist)
{
size_t i, f, maxread = 0, readcap = 512, newcap, carry;
long double *sumprob = malloc(readcap * sizeof(long double));
size_t *counts = malloc(readcap * sizeof(size_t));
for(i = 0; i < readcap; i++) { sumprob[i] = 0; counts[i] = 0; }
read_t *r = &flist->read;
int fmt, fqoffset = 33, minq, maxq;
for(f = flist->curr; f < flist->num_files; f++) {
fmt = seq_guess_fastq_format(flist->files[f], &minq, &maxq);
fqoffset = (fmt == -1 ? 33 : FASTQ_OFFSET[fmt]);
while(seq_read(flist->files[f], r) > 0) {
if(r->qual.end > readcap) {
newcap = ROUNDUP2POW(r->qual.end);
sumprob = realloc(sumprob, newcap * sizeof(long double));
counts = realloc(counts, newcap * sizeof(size_t));
for(i = readcap; i < newcap; i++) { sumprob[i] = 0; counts[i] = 0; }
readcap = newcap;
}
counts[r->qual.end-1]++;
for(i = 0; i < r->qual.end; i++)
sumprob[i] += qual_prob[r->qual.b[i] - fqoffset];
maxread = MAX2(maxread, r->qual.end);
}
}
// Convert counts to cummulative (reverse)
for(i = maxread-1, carry = 0; i != SIZE_MAX; i--) {
carry += counts[i];
counts[i] = carry;
}
for(i = 0; i < maxread; i++) {
// printf(" %.8Lf/%zu", sumprob[i], counts[i]);
printf(" %.2Lf", 100.0 * sumprob[i] / counts[i]);
} printf("\n");
free(counts);
free(sumprob);
}
void aligner_align(aligner_t *aligner,
const char *seq_a, const char *seq_b,
size_t len_a, size_t len_b,
const scoring_t *scoring, char is_sw)
{
aligner->scoring = scoring;
aligner->seq_a = seq_a;
aligner->seq_b = seq_b;
aligner->score_width = len_a+1;
aligner->score_height = len_b+1;
size_t new_capacity = aligner->score_width * aligner->score_height;
if(aligner->capacity < new_capacity)
{
aligner->capacity = ROUNDUP2POW(new_capacity);
size_t mem = sizeof(score_t) * aligner->capacity;
aligner->match_scores = realloc(aligner->match_scores, mem);
aligner->gap_a_scores = realloc(aligner->gap_a_scores, mem);
aligner->gap_b_scores = realloc(aligner->gap_b_scores, mem);
}
alignment_fill_matrices(aligner, is_sw);
}
