// Backtrack through scoring matrices
void alignment_reverse_move(enum Matrix *curr_matrix, score_t *curr_score,
size_t *score_x, size_t *score_y,
size_t *arr_index, const aligner_t *aligner)
{
size_t seq_x = (*score_x)-1, seq_y = (*score_y)-1;
size_t len_i = aligner->score_width-1, len_j = aligner->score_height-1;
bool is_match;
int match_penalty;
const scoring_t *scoring = aligner->scoring;
scoring_lookup(scoring, aligner->seq_a[seq_x], aligner->seq_b[seq_y],
&match_penalty, &is_match);
int gap_a_open_penalty, gap_b_open_penalty;
int gap_a_extend_penalty, gap_b_extend_penalty;
gap_a_open_penalty = gap_b_open_penalty = scoring->gap_extend + scoring->gap_open;
gap_a_extend_penalty = gap_b_extend_penalty = scoring->gap_extend;
// Free gaps at the ends
if(scoring->no_end_gap_penalty) {
if(*score_x == len_i) gap_a_open_penalty = gap_a_extend_penalty = 0;
if(*score_y == len_j) gap_b_open_penalty = gap_b_extend_penalty = 0;
}
if(scoring->no_start_gap_penalty) {
if(*score_x == 0) gap_a_open_penalty = gap_a_extend_penalty = 0;
if(*score_y == 0) gap_b_open_penalty = gap_b_extend_penalty = 0;
}
long prev_match_penalty, prev_gap_a_penalty, prev_gap_b_penalty;
switch(*curr_matrix)
{
case MATCH:
prev_match_penalty = match_penalty;
prev_gap_a_penalty = match_penalty;
prev_gap_b_penalty = match_penalty;
(*score_x)--;
(*score_y)--;
(*arr_index) -= aligner->score_width + 1;
break;
case GAP_A:
prev_match_penalty = gap_a_open_penalty;
prev_gap_a_penalty = gap_a_extend_penalty;
prev_gap_b_penalty = gap_a_open_penalty;
(*score_y)--;
(*arr_index) -= aligner->score_width;
break;
case GAP_B:
prev_match_penalty = gap_b_open_penalty;
prev_gap_a_penalty = gap_b_open_penalty;
prev_gap_b_penalty = gap_b_extend_penalty;
(*score_x)--;
(*arr_index)--;
break;
default:
fprintf(stderr, "Program error: invalid matrix in get_reverse_move()\n");
fprintf(stderr, "Please submit a bug report to: [email protected]\n");
exit(EXIT_FAILURE);
}
// *arr_index = ARR_2D_INDEX(aligner->score_width, *score_x, *score_y);
if((!scoring->no_gaps_in_a || *score_x == 0 || *score_x == len_i) &&
(long)aligner->gap_a_scores[*arr_index] + prev_gap_a_penalty == *curr_score)
{
*curr_matrix = GAP_A;
*curr_score = aligner->gap_a_scores[*arr_index];
}
else if((!scoring->no_gaps_in_b || *score_y == 0 || *score_y == len_j) &&
(long)aligner->gap_b_scores[*arr_index] + prev_gap_b_penalty == *curr_score)
{
*curr_matrix = GAP_B;
*curr_score = aligner->gap_b_scores[*arr_index];
}
else if((long)aligner->match_scores[*arr_index] + prev_match_penalty == *curr_score)
{
*curr_matrix = MATCH;
*curr_score = aligner->match_scores[*arr_index];
}
else
{
alignment_print_matrices(aligner);
fprintf(stderr, "[%s:%zu,%zu]: %i [ismatch: %i] '%c' '%c'\n",
MATRIX_NAME(*curr_matrix), *score_x, *score_y, *curr_score,
is_match, aligner->seq_a[seq_x], aligner->seq_b[seq_y]);
fprintf(stderr, " Penalties match: %li gap_open: %li gap_extend: %li\n",
prev_match_penalty, prev_gap_a_penalty, prev_gap_b_penalty);
fprintf(stderr, " Expected MATCH: %i GAP_A: %i GAP_B: %i\n",
aligner->match_scores[*arr_index],
aligner->gap_a_scores[*arr_index],
aligner->gap_b_scores[*arr_index]);
fprintf(stderr,
"Program error: traceback fail (get_reverse_move)\n"
"This may be due to an integer overflow if your sequences are long or scores\n"
"are large. If this is the case using smaller scores or shorter sequences may\n"
"work around this problem. \n"
" If you think this is a bug, please report it to: [email protected]\n");
exit(EXIT_FAILURE);
}
}
// Fill in traceback matrix
static void alignment_fill_matrices(aligner_t *aligner, char is_sw)
{
score_t *match_scores = aligner->match_scores;
score_t *gap_a_scores = aligner->gap_a_scores;
score_t *gap_b_scores = aligner->gap_b_scores;
const scoring_t *scoring = aligner->scoring;
size_t score_width = aligner->score_width;
size_t score_height = aligner->score_height;
size_t i, j;
const score_t min = is_sw ? 0 : SCORE_MIN;
size_t seq_i, seq_j, len_i = score_width-1, len_j = score_height-1;
size_t index, index_left, index_up, index_upleft;
// [0][0]
match_scores[0] = 0;
gap_a_scores[0] = 0;
gap_b_scores[0] = 0;
if(is_sw)
{
for(i = 1; i < score_width; i++)
match_scores[i] = gap_a_scores[i] = gap_b_scores[i] = 0;
for(j = 1, index = score_width; j < score_height; j++, index += score_width)
match_scores[index] = gap_a_scores[index] = gap_b_scores[index] = min;
}
else
{
// work along first row -> [i][0]
for(i = 1; i < score_width; i++)
{
match_scores[i] = min;
// Think carefully about which way round these are
gap_a_scores[i] = min;
gap_b_scores[i] = scoring->no_start_gap_penalty ? 0
: scoring->gap_open + (long)i * scoring->gap_extend;
}
// work down first column -> [0][j]
for(j = 1, index = score_width; j < score_height; j++, index += score_width)
{
match_scores[index] = min;
// Think carefully about which way round these are
gap_a_scores[index] = scoring->no_start_gap_penalty ? 0
: scoring->gap_open + (long)j * scoring->gap_extend;
gap_b_scores[index] = min;
}
}
// These are longs to force addition to be done with higher accuracy
long gap_open_penalty = scoring->gap_extend + scoring->gap_open;
long gap_extend_penalty = scoring->gap_extend;
long substitution_penalty;
// start at position [1][1]
index_upleft = 0;
index_up = 1;
index_left = score_width;
index = score_width+1;
for(seq_j = 0; seq_j < len_j; seq_j++)
{
for(seq_i = 0; seq_i < len_i; seq_i++)
{
// Update match_scores[i][j] with position [i-1][j-1]
// substitution penalty
bool is_match;
int tmp_penalty;
scoring_lookup(scoring, aligner->seq_a[seq_i], aligner->seq_b[seq_j],
&tmp_penalty, &is_match);
if(scoring->no_mismatches && !is_match)
{
match_scores[index] = min;
}
else
{
substitution_penalty = tmp_penalty; // cast to long
// substitution
// 1) continue alignment
// 2) close gap in seq_a
// 3) close gap in seq_b
match_scores[index]
= max4(match_scores[index_upleft] + substitution_penalty,
gap_a_scores[index_upleft] + substitution_penalty,
gap_b_scores[index_upleft] + substitution_penalty,
min);
}
// Long arithmetic since some INTs are set to min and penalty is -ve
// (adding as ints would cause an integer overflow)
// Update gap_a_scores[i][j] from position [i][j-1]
if(seq_i == len_i-1 && scoring->no_end_gap_penalty)
{
gap_a_scores[index] = MAX3(match_scores[index_up],
gap_a_scores[index_up],
gap_b_scores[index_up]);
}
else if(!scoring->no_gaps_in_a || seq_i == len_i-1)
{
gap_a_scores[index]
= max4(match_scores[index_up] + gap_open_penalty,
gap_a_scores[index_up] + gap_extend_penalty,
gap_b_scores[index_up] + gap_open_penalty,
min);
}
else
gap_a_scores[index] = min;
// Update gap_b_scores[i][j] from position [i-1][j]
if(seq_j == len_j-1 && scoring->no_end_gap_penalty)
{
gap_b_scores[index] = MAX3(match_scores[index_left],
gap_a_scores[index_left],
gap_b_scores[index_left]);
}
else if(!scoring->no_gaps_in_b || seq_j == len_j-1)
{
gap_b_scores[index]
= max4(match_scores[index_left] + gap_open_penalty,
gap_a_scores[index_left] + gap_open_penalty,
gap_b_scores[index_left] + gap_extend_penalty,
min);
}
else
gap_b_scores[index] = min;
index++;
index_left++;
index_up++;
index_upleft++;
}
index++;
index_left++;
index_up++;
index_upleft++;
}
}
void alignment_reverse_move(enum Matrix *curr_matrix, score_t* curr_score,
unsigned int *score_x, unsigned int *score_y,
unsigned long *arr_index,
unsigned int score_width,
score_t *match_score, score_t *gap_a_score,
score_t *gap_b_score,
char* seq_a, char* seq_b,
SCORING_SYSTEM* scoring)
{
int prev_match_penalty, prev_gap_a_penalty, prev_gap_b_penalty;
unsigned int seq_x = (*score_x)-1;
unsigned int seq_y = (*score_y)-1;
int match_penalty = scoring_lookup(scoring, seq_a[seq_x], seq_b[seq_y]);
switch(*curr_matrix)
{
case MATCH:
prev_match_penalty = match_penalty;
prev_gap_a_penalty = match_penalty;
prev_gap_b_penalty = match_penalty;
(*score_x)--;
(*score_y)--;
break;
case GAP_A:
prev_match_penalty = scoring->gap_extend + scoring->gap_open;
prev_gap_a_penalty = scoring->gap_extend;
prev_gap_b_penalty = scoring->gap_extend + scoring->gap_open;
(*score_y)--;
break;
case GAP_B:
prev_match_penalty = scoring->gap_extend + scoring->gap_open;
prev_gap_a_penalty = scoring->gap_extend + scoring->gap_open;
prev_gap_b_penalty = scoring->gap_extend;
(*score_x)--;
break;
default:
fprintf(stderr, "Program error: invalid matrix in get_reverse_move()\n");
fprintf(stderr, "Please submit a bug report to: [email protected]\n");
exit(EXIT_FAILURE);
}
*arr_index = ARR_2D_INDEX(score_width, *score_x, *score_y);
if((long)match_score[*arr_index] + prev_match_penalty == *curr_score)
{
*curr_matrix = MATCH;
*curr_score = match_score[*arr_index];
}
else if((long)gap_a_score[*arr_index] + prev_gap_a_penalty == *curr_score)
{
*curr_matrix = GAP_A;
*curr_score = gap_a_score[*arr_index];
}
else if((long)gap_b_score[*arr_index] + prev_gap_b_penalty == *curr_score)
{
*curr_matrix = GAP_B;
*curr_score = gap_b_score[*arr_index];
}
else
{
fprintf(stderr, "Program error: traceback fail (get_reverse_move)\n");
fprintf(stderr, "This may be due to an integer overflow if your "
"sequences are long or if scores are large. \n");
fprintf(stderr, "If this is the case using smaller scores or "
"shorter sequences may work around this problem. \n");
fprintf(stderr, " If you think this is a bug, please report it to: "
"[email protected]\n");
exit(EXIT_FAILURE);
}
}