Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/jumper_8c_source.html below:

NCBI C++ ToolKit: src/algo/blast/core/jumper.c Source File

(

= 0;

< 256;

++) {

(k = 0;k < 4; k++) {

cell = ((

>> (2 * k)) & 3);

0:

[

] += cell << 3 * 8;

;

1:

[

] += cell << 2 * 8;

;

2:

[

] += cell << 1 * 8;

;

3:

[

] += cell;

;

(jgap_align->

) {

(!retval->

) {

(!left || !right) {

* query_pos,

* subject_pos)

(edit_index < edit_script->num_ops);

(!edit_script || !query_pos || !subject_pos) {

(j = 0;j < edit_index;j++) {

(j < edit_script->num_ops);

*query_pos += edit_script->

[j];

*subject_pos += edit_script->

[j];

query_offset,

subject_offset,

query_length,

subject_length,

(score && num_identical);

(

= 0;

< edit_script->

;

++) {

(k < edit_script->num_ops &&

(;k < edit_script->

;k++) {

(edit_script->

[k] < 0 &&

(j = k;j < edit_script->

- 1;j++) {

(*score) -= err_score;

q_pos = query_offset;

s_pos = subject_offset;

q_pos = query_offset;

s_pos = subject_offset;

(*score) -= err_score;

(edit_script->

[k] > 0) {

q_pos = query_offset;

s_pos = subject_offset;

(b < edit_script->edit_ops[k] &&

(q_pos <= query_length);

(s_pos <= subject_length);

(edit_script->

[

- 1] <= 0) {

(j = edit_script->

- 1;j >

;j--) {

(

< num_matches) {

(j = k;j < edit_script->

- 1;j++) {

query_length,

subject_length,

err_score,

* num_identical)

(k =

+ 1;k < combined->

;k++) {

subject_length, &gap_align->

,

err_score, num_identical);

(combined->

> 0 &&

gap_align->

-= err_score;

num_matches = 0;

(jops->

== 0 || margin == 0) {

(index >= 1 && jops->

[index] > 0) {

num_matches += jops->

[index];

(jops->

> 1 && num_matches < margin) {

(*cp) += (is_right_ext ? -op : op);

(*cq) += (is_right_ext ? -op : op);

*num_identical -= op;

(is_right_ext) {

(index >= jops->

) {

(index >= 1 && jops->

[index] > 0) {

num_matches += jops->

[index];

(rev_prelim_block->

== 0 && fwd_prelim_block->

== 0) {

last_op = rev_prelim_block->

> 0 ?

(

= rev_prelim_block->

- 2;

>= 0;

--) {

(

= 0;

< fwd_prelim_block->

;

++) {

(rev_prelim_block->

> 0) {

last_op = retval->

[index];

(;

>= 0;

--) {

(current_op == last_op) {

last_op = current_op;

(index == 0 && retval->

[index] == 0) {

last_op = retval->

[index];

(;

< fwd_prelim_block->

;

++) {

(current_op == last_op) {

last_op = current_op;

match_score,

mismatch_score,

gap_open_score,

gap_extend_score)

(

= 0;

< edit_script->

;

++) {

score += op * match_score;

score += mismatch_score;

score += gap_open_score;

(i < edit_script->num_ops && edit_script->

[

] == op) {

score += gap_extend_score;

query_length,

subject_length,

match_score,

mismatch_score,

gap_open_score,

gap_extend_score,

max_mismatches,

window,

*

,

* query_ext_len,

* subject_ext_len,

* num_identical,

* ungapped_ext_len)

*cp, *cp1, *cpmax, *cpmax4, *cpstop =

;

cq, cq1, cqmax, cqmax4, cqstop = 0;

num_mismatches = 0;

trace_mask = (1 << max_mismatches) - 1;

score = 0, best_score = 0;

cpmax = cp + query_length;

cqmax = subject_length;

(cp < cpmax && cq < cqmax && num_mismatches < max_mismatches) {

(!(cq & 3) && cp < cpmax4 && cq < cqmax4) {

cp1 = cp + jp->

;

cq1 = cq + jp->

;

(cp1 >= cpmax || cq1 >= cqmax

cp1 = cp + jp->

;

cq1 = cq + jp->

;

(

+ cp1 >= cpmax ||

+ cq1 >= cqmax) {

(cp1 >= cpmax || cq1 >= cqmax) {

(++

> jp->

) {

(new_matches < window) {

<<= new_matches;

*num_identical += new_matches;

score += new_matches * match_score;

(jp->

== jp->

) {

score += mismatch_score * jp->

;

(

& trace_mask) {

num_mismatches += jp->

;

num_mismatches = jp->

;

(is_ungapped && jp->

!= jp->

) {

*ungapped_ext_len = (

)(cp -

- 1);

is_ungapped =

;

(jp->

== 0 && jp->

) {

*num_identical += jp->

;

score += jp->

* match_score;

(score >= best_score) {

*num_identical += new_matches;

score += new_matches * match_score;

(score >= best_score) {

*query_ext_len = (

)(cpstop -

);

*subject_ext_len = cqstop;

*ungapped_ext_len = *query_ext_len;

query_length,

subject_length,

match_score,

mismatch_score,

gap_open_score,

gap_extend_score,

max_mismatches,

window,

*

,

* query_ext_len,

* subject_ext_len,

* num_identical,

* ungapped_ext_len,

*cp, *cp1, *cpmax, *cpmax4;

cq, cq1, cqmax, cqmax4;

num_mismatches = 0;

trace_mask = (1 << max_mismatches) - 1;

cpmax = cp + query_length;

cqmax = subject_length;

(!left_extension) {

(cp < cpmax && cq < cqmax && num_mismatches < max_mismatches) {

(!(cq & 3) && cp < cpmax4 && cq < cqmax4) {

cp1 = cp + jp->

;

cq1 = cq + jp->

;

(cp1 >= cpmax || cq1 >= cqmax

cp1 = cp + jp->

;

cq1 = cq + jp->

;

(

+ cp1 >= cpmax ||

+ cq1 >= cqmax) {

(cp1 >= cpmax || cq1 >= cqmax) {

(++

> jp->

) {

(new_matches < window) {

<<= new_matches;

*num_identical += new_matches;

(jp->

== jp->

) {

(

& trace_mask) {

num_mismatches += jp->

;

num_mismatches = jp->

;

(

= 0;

< jp->

;

++) {

}

(jp->

> jp->

) {

(

= 0;

< jp->

- jp->

;

++) {

(

= 0;

< jp->

- jp->

;

++) {

(is_ungapped && jp->

!= jp->

) {

*ungapped_ext_len = (

)(cp -

- 1);

is_ungapped =

;

(jp->

== 0 && jp->

) {

*num_identical += jp->

;

*num_identical += new_matches;

(edit_script, -mismatch_score, &cp, &cq, num_identical,

*subject_ext_len = cq;

*ungapped_ext_len = *query_ext_len;

gap_open_score, gap_extend_score);

query_length,

subject_length,

match_score,

mismatch_score,

gap_open_score,

gap_extend_score,

max_mismatches,

window,

* query_ext_len,

* subject_ext_len,

* best_num_identical,

* ungapped_ext_len)

*cp, *cp1, *cpmax, *cpmax4, *cpstop =

;

cq, cq1, cqmax, cqmax4, cqstop = 0;

num_mismatches = 0;

new_matches = 0;

trace_mask = (1 << max_mismatches) - 1;

score = 0, best_score = 0;

num_ops = 0, num_identical = *best_num_identical;

last_gap_open = 0;

cpmax = cp + query_length;

cqmax = subject_length;

(!left_extension) {

(cp < cpmax && cq < cqmax && num_mismatches < max_mismatches) {

(!(cq & 3) && cp < cpmax4 && cq < cqmax4) {

cp1 = cp + jp->

;

cq1 = cq + jp->

;

(cp1 >= cpmax || cq1 >= cqmax

cp1 = cp + jp->

;

cq1 = cq + jp->

;

(cp1 >= cpmax ||

+ cq1 >= cqmax) {

(

cq1 >= cqmax) {

(++

> jp->

) {

(new_matches < window) {

<<= new_matches;

num_identical += new_matches;

score += new_matches * match_score;

(score >= best_score) {

num_ops = edit_script->

;

*best_num_identical = num_identical;

(best_score - score > x_drop) {

(jp->

== jp->

) {

score += jp->

* mismatch_score;

(

& trace_mask) {

num_mismatches += jp->

;

num_mismatches = jp->

;

(

= 0;

< jp->

;

++) {

}

(jp->

> jp->

) {

(

= 0;

< jp->

- jp->

;

++) {

score += gap_extend_score;

score += gap_open_score;

(

= 0;

< jp->

- jp->

;

++) {

score += gap_extend_score;

score += gap_open_score;

(is_ungapped && jp->

!= jp->

) {

*ungapped_ext_len = (

)(cp -

- 1);

is_ungapped =

;

(cp1 < cpmax && jp->

== 0 && jp->

) {

num_identical += jp->

;

score += jp->

* match_score;

(score >= best_score) {

num_ops = edit_script->

;

*best_num_identical = num_identical;

num_identical += new_matches;

score += new_matches;

(score >= best_score) {

num_ops = edit_script->

;

*best_num_identical = num_identical;

*query_ext_len = (

)(cpstop -

);

*subject_ext_len = cqstop;

edit_script->

= num_ops;

*ungapped_ext_len = *query_ext_len;

query_length,

subject_length,

match_score,

mismatch_score,

gap_open_score,

gap_extend_score,

max_mismatches,

window,

* query_ext_len,

* subject_ext_len,

*cp, *cp1, *cpmax;

cq, cq1, cqmax;

score = 0, num_mismatches = 0;

new_matches = 0;

trace_mask = (1 << max_mismatches) - 1;

cpmax = cp + query_length;

cqmax = subject_length;

(!left_extension) {

(cp < cpmax && cq < cqmax && num_mismatches < max_mismatches) {

score += match_score;

cp1 = cp + jp->

;

cq1 = cq + jp->

;

(cp1 >= cpmax || cq1 >= cqmax

cp1 = cp + jp->

;

cq1 = cq + jp->

;

(

+ cp1 >= cpmax ||

+ cq1 >= cqmax) {

(cp1 >= cpmax || cq1 >= cqmax) {

(*cp1++ !=

[cq1]) {

(++

> jp->

) {

(new_matches < window) {

<<= new_matches;

(jp->

== jp->

) {

score += mismatch_score * jp->

;

(

& trace_mask) {

num_mismatches += jp->

;

num_mismatches = jp->

;

}

(jp->

> jp->

) {

score += gap_open_score + gap_extend_score * (jp->

- jp->

);

score += gap_open_score + gap_extend_score * (jp->

- jp->

);

(jp->

== 0 && jp->

) {

score += match_score * jp->

;

*subject_ext_len = cq;

query_length,

subject_length,

match_score,

mismatch_score,

gap_open_score,

gap_extend_score,

max_mismatches,

window,

* query_ext_len,

* subject_ext_len,

* num_identical,

* ungapped_ext_len,

*cp, *cp1, *cpmax;

cq, cq1, cqmax;

num_mismatches = 0;

new_matches = 0;

trace_mask = (1 << max_mismatches) - 1;

cpmax = cp + query_length;

cqmax = subject_length;

(left_extension) {

(cp < cpmax && cq < cqmax && num_mismatches < max_mismatches) {

cp1 = cp + jp->

;

cq1 = cq + jp->

;

(cp1 >= cpmax || cq1 >= cqmax

cp1 = cp + jp->

;

cq1 = cq + jp->

;

(

+ cp1 >= cpmax ||

+ cq1 >= cqmax) {

(cp1 >= cpmax || cq1 >= cqmax) {

(*cp1++ !=

[cq1]) {

(++

> jp->

) {

(new_matches < window) {

<<= new_matches;

*num_identical += new_matches;

(jp->

== jp->

) {

(

& trace_mask) {

num_mismatches += jp->

;

num_mismatches = jp->

;

(

= 0;

< jp->

;

++) {

}

(jp->

> jp->

) {

(

= 0;

< jp->

- jp->

;

++) {

(

= 0;

< jp->

- jp->

;

++) {

(is_ungapped && jp->

!= jp->

) {

*ungapped_ext_len = (

)(cp -

- 1);

is_ungapped =

;

(jp->

== 0 && jp->

) {

*num_identical += jp->

;

*num_identical += new_matches;

(edit_script, -mismatch_score, &cp, &cq, num_identical,

*subject_ext_len = cq;

*ungapped_ext_len = *query_ext_len;

gap_open_score, gap_extend_score);

query_offset,

subject_offset,

match_score,

mismatch_score,

gap_open_score,

gap_extend_score,

max_mismatches,

window,

*

,

* query_ext_len,

* subject_ext_len,

* num_identical)

*cp, *cp1, *cpmin, *cpmin4, *cpstop =

;

cq, cq1, cqmin, cqmin4, cqstop = 0;

num_mismatches = 0;

new_matches = 0;

trace_mask = (1 << max_mismatches) - 1;

score = 0, best_score = 0;

cp =

+ query_offset;

cq = subject_offset;

(cp >= cpmin && cq >= cqmin && num_mismatches < max_mismatches) {

((cq & 3) == 3 && cp >= cpmin4 && cq >= cqmin4) {

cp1 = cp - jp->

;

cq1 = cq - jp->

;

(cp1 < cpmin || cq1 < cqmin

cp1 = cp - jp->

;

cq1 = cq - jp->

;

(cp1 -

< cpmin || cq1 -

< cqmin) {

(cp1 < cpmin || cq1 < cqmin) {

(++

> jp->

) {

(new_matches < window) {

<<= new_matches;

*num_identical += new_matches;

score = new_matches * match_score;

(jp->

== jp->

) {

score += mismatch_score * jp->

;

(

& trace_mask) {

num_mismatches += jp->

;

num_mismatches = jp->

;

(!jp->

&& jp->

) {

*num_identical += jp->

;

score += jp->

* match_score;

(score >= best_score) {

*num_identical += new_matches;

score += new_matches * match_score;

(score >= best_score) {

*query_ext_len = (

)(

+ query_offset - cpstop);

*subject_ext_len = subject_offset - cqstop;

query_offset,

subject_offset,

match_score,

mismatch_score,

gap_open_score,

gap_extend_score,

max_mismatches,

window,

*

,

* query_ext_len,

* subject_ext_len,

* num_identical,

*cp, *cp1, *cpmin, *cpmin4;

cq, cq1, cqmin, cqmin4;

num_mismatches = 0;

new_matches = 0;

trace_mask = (1 << max_mismatches) - 1;

cp =

+ query_offset;

cq = subject_offset;

(cp >= cpmin && cq >= cqmin && num_mismatches < max_mismatches) {

((cq & 3) == 3 && cp >= cpmin4 && cq >= cqmin4) {

cp1 = cp - jp->

;

cq1 = cq - jp->

;

(cp1 < cpmin || cq1 < cqmin

cp1 = cp - jp->

;

cq1 = cq - jp->

;

(cp1 -

< cpmin || cq1 -

< cqmin) {

(cp1 < cpmin || cq1 < cqmin) {

(++

> jp->

) {

(new_matches < window) {

<<= new_matches;

*num_identical += new_matches;

(jp->

== jp->

) {

(

& trace_mask) {

num_mismatches += jp->

;

num_mismatches = jp->

;

(

= 0;

< jp->

;

++) {

}

(jp->

> jp->

) {

(

= 0;

< jp->

- jp->

;

++) {

(

= 0;

< jp->

- jp->

;

++) {

(!jp->

&& jp->

) {

*num_identical += jp->

;

*num_identical += new_matches;

(edit_script, -mismatch_score, &cp, &cq, num_identical,

*query_ext_len = (

)(

+ query_offset - cp);

*subject_ext_len = subject_offset - cq;

gap_open_score, gap_extend_score);

query_offset,

subject_offset,

match_score,

mismatch_score,

gap_open_score,

gap_extend_score,

max_mismatches,

window,

* query_ext_len,

* subject_ext_len,

* best_num_identical)

*cp, *cp1, *cpmin, *cpmin4, *cpstop =

;

cq, cq1, cqmin, cqmin4, cqstop = 0;

num_mismatches = 0;

new_matches = 0;

trace_mask = (1 << max_mismatches) - 1;

score = 0, best_score = 0;

num_ops = 0, num_identical = *best_num_identical;

last_gap_open = 0;

cp =

+ query_offset;

cq = subject_offset;

(cp >= cpmin && cq >= cqmin && num_mismatches < max_mismatches) {

((cq & 3) == 3 && cp >= cpmin4 && cq >= cqmin4) {

cp1 = cp - jp->

;

cq1 = cq - jp->

;

(cp1 < cpmin || cq1 < cqmin

cp1 = cp - jp->

;

cq1 = cq - jp->

;

(cp1 <= cpmin || cq1 -

< cqmin) {

(++

> jp->

) {

(new_matches < window) {

<<= new_matches;

num_identical += new_matches;

score += new_matches * match_score;

(score >= best_score) {

num_ops = edit_script->

;

*best_num_identical = num_identical;

(best_score - score > x_drop) {

(jp->

== jp->

) {

score += jp->

* mismatch_score;

(

& trace_mask) {

num_mismatches += jp->

;

num_mismatches = jp->

;

(

= 0;

< jp->

;

++) {

}

(jp->

> jp->

) {

(

= 0;

< jp->

- jp->

;

++) {

score += gap_extend_score;

score += gap_open_score;

(

= 0;

< jp->

- jp->

;

++) {

score += gap_extend_score;

score += gap_open_score;

(cp1 > cpmin && !jp->

&& jp->

) {

num_identical += jp->

;

score += jp->

* match_score;

(score >= best_score) {

num_ops = edit_script->

;

*best_num_identical = num_identical;

num_identical += new_matches;

score += new_matches * match_score;

(score >= best_score) {

num_ops = edit_script->

;

*best_num_identical = num_identical;

*query_ext_len = (

)(

+ query_offset - cpstop);

*subject_ext_len = subject_offset - cqstop;

edit_script->

= num_ops;

query_offset,

subject_offset,

match_score,

mismatch_score,

gap_open_score,

gap_extend_score,

max_mismatches,

window,

* query_ext_len,

* subject_ext_len,

*cp, *cp1, *cpmin;

cq, cq1, cqmin;

score = 0, num_mismatches = 0;

new_matches = 0;

trace_mask = (1 << max_mismatches) - 1;

cp =

+ query_offset;

cq = subject_offset;

(cp >= cpmin && cq >= cqmin && num_mismatches < max_mismatches) {

score += match_score;

cp1 = cp - jp->

;

cq1 = cq - jp->

;

(cp1 < cpmin || cq1 < cqmin

cp1 = cp - jp->

;

cq1 = cq - jp->

;

(cp1 -

< cpmin || cq1 -

< cqmin) {

(cp1 < cpmin || cq1 < cqmin) {

(*cp1-- !=

[cq1]) {

(++

> jp->

) {

(new_matches < window) {

<<= new_matches;

(jp->

== jp->

) {

score += mismatch_score * jp->

;

(

& trace_mask) {

num_mismatches += jp->

;

num_mismatches = jp->

;

}

(jp->

> jp->

) {

score += gap_open_score + gap_extend_score * (jp->

- jp->

);

score += gap_open_score + gap_extend_score * (jp->

- jp->

);

(!jp->

&& jp->

) {

score += match_score * jp->

;

*query_ext_len = (

)(

+ query_offset - cp);

*subject_ext_len = subject_offset - cq;

query_length,

subject_length,

query_start,

subject_start,

* num_identical,

* right_ungapped_ext_len)

score_left = 0, score_right = 0;

q_ext_len, s_ext_len;

q_length, s_length;

offset_adjustment;

kBaseN = 14;

(!*rev_prelim_block || !*fwd_prelim_block ||

2 *

(query_length, subject_length)) {

q_length = query_start + offset_adjustment;

s_length = subject_start + offset_adjustment;

(query_start > 0 && subject_start > 0) {

&q_ext_len, &s_ext_len,

gap_align->

= q_length - q_ext_len + 1;

left_ext_done =

;

(query_start < query_length - 1 && subject_start < subject_length - 1) {

query_length - q_length,

subject_length - s_length,

&q_ext_len, &s_ext_len,

right_ungapped_ext_len);

gap_align->

= q_length + q_ext_len;

gap_align->

= score_left + score_right;

(offset_adjustment && !left_ext_done) {

((*rev_prelim_block)->num_ops <

(*rev_prelim_block)->num_allocated);

*num_identical += offset_adjustment;

gap_align->

+= offset_adjustment * score_params->

;

(offset_adjustment && *right_ungapped_ext_len) {

*right_ungapped_ext_len += offset_adjustment;

(

= gap_align->

;i < gap_align->query_stop;

++) {

(

[

] == kBaseN) {

(100.0 * (

)num_identical / (

)align_len

(score < cutoff_score) {

edit_dist = align_len - num_identical;

(block->

) {

(!retval->

) {

kGap = 15;

(

=left_ext->

- 1;

>= 0;

--) {

->query_pos = q_pos;

->query_pos = q_pos;

->query_base = kGap;

->query_pos = q_pos;

->subject_base = kGap;

(

=0;

< right_ext->

;

++) {

->query_pos = q_pos;

->query_pos = q_pos;

->query_base = kGap;

->query_pos = q_pos;

->subject_base = kGap;

(!block_ptr || !*block_ptr || !append_ptr) {

(!block->

) {

(

= 0;

<

->num_edits;

++) {

(!edit_script_ptr || !*edit_script_ptr || !append_ptr) {

edit_script = *edit_script_ptr;

(!edit_script->

) {

edit_script->

= realloc(edit_script->

,

(!edit_script->

) {

edit_script->

[edit_script->

- 1] +=

->num[0];

edit_script->

++;

(overhangs->

) {

(overhangs->

) {

kMinOverhangLength = 0;

kMaxSubjectOverhang = query_len < 400 ? 30 : 60;

query_len - hsp->

.

< kMinOverhangLength) {

(

= 0;

<

;

++) {

overhangs->

= overhang;

(hsp->

.

<= query_len - kMinOverhangLength) {

(query_len - hsp->

.

+ 1 < 6)

(

(query_len - hsp->

.

+ 1, 2), kMaxSubjectOverhang);

= kMaxSubjectOverhang;

(

= 0;

<

;

++) {

overhangs->

= overhang;

first_diag =

->qs_offsets.s_off -

->qs_offsets.q_off;

(first_diag < second_diag) {

(first_diag > second_diag) {

edit_script->

[0] = length;

(

= 0;

< length;

++) {

((

[q_offset +

] & 0xfc) != 0) {

(

= 0;

< length;

++) {

((

[q_offset +

] & 0xfc) != 0) {

->query_pos = q_offset +

;

num_identical = 0;

(!getenv(

)) {

score_params->

, &num_identical);

(!new_hsp || status) {

hits_extended = 0;

word_length, lut_word_length, ext_to;

num_identical = 0;

skip_until = 0;

ext_to = word_length - lut_word_length;

(; index < num_hits; ++index) {

diag = s_offset - q_offset;

(diag == last_diag && q_offset < skip_until) {

s_off = s_offset;

(; ext_left <

(ext_to, s_offset); ++ext_left) {

(ext_left < ext_to) {

s_off = s_offset + lut_word_length;

(s_off + ext_to - ext_left > s_range)

q =

->sequence + q_offset + lut_word_length;

(; ext_right < ext_to - ext_left; ++ext_right) {

(ext_left + ext_right < ext_to)

q_offset -= ext_left;

s_offset -= ext_left;

q_offset -= query_start;

* query_seq =

->sequence + query_start;

right_ungapped_ext_len = 0;

&right_ungapped_ext_len);

skip_until = q_offset + query_start + right_ungapped_ext_len;

* query_seq =

->sequence + query_start;

kMinSubjectOverhang = 100;

(!getenv(

)) {

score_params->

, &num_identical);

(getenv(

) &&

query_len - new_hsp->

.

< 16 &&

(

= 1;

< query_len - new_hsp->

.

;

++) {

(query_seq[new_hsp->

.

+

] !=

(

> 4 ||

== query_len - new_hsp->

.

) {

((query_seq[q +

] & 0xfc) != 0) {

word = (query_seq[q] << 6) | (query_seq[q + 1] << 4) |

(query_seq[q + 2] << 2) | query_seq[q + 3];

word = (word << 2) | query_seq[q +

];

((from + kMaxIntronLength),

(

->length - (query_len - q + 1))));

(qt < query_len && st < subject->length &&

(query_seq[qt] & 0xfc) != 0)) {

(qt == query_len) {

(qf >= 0 && sf >= 0 &&

(query_seq[qf] & 0xfc) != 0)) {

qf <= new_hsp->

.offset) {

(qf < qt && (query_seq[qf] & 0xfc) != 0) {

(qt > qf && (query_seq[qt - 1] & 0xfc) != 0) {

(getenv(

) &&

(; !found && q >= 0 &&

< 2;q--,

++) {

((query_seq[q +

] & 0xfc) != 0) {

word = (query_seq[q] << 6) | (query_seq[q + 1] << 4) |

(query_seq[q + 2] << 2) | query_seq[q + 3];

word = (word << 2) | query_seq[q +

];

(from - kMaxIntronLength, q + 1));

(query_seq[k] & 0xfc) != 0)) {

(qt < query_len && st < subject->length &&

(query_seq[qt] & 0xfc) != 0)) {

(k < qt && (query_seq[k] & 0xfc) != 0) {

(qt > k && (query_seq[qt] & 0xfc) != 0) {

hits_extended;

(seqloc->

) {

(

= 0;

<

->length / 4;

++) {

(k = 0;k < 4;k++) {

(

->sequence[

] >> (2 * (3 - k))) & 3;

(

= 0;

< num_lookups;

++) {

ssr->

= width *

;

query_opt, word_size);

retval->

= width;

(!s_index || !s_index->

[0]) {

word = word &

->mask;

->thick_backbone[word].payload.overflow_cursor;

retval->

= word;

->thick_backbone[it->

].payload.overflow_cursor;

(pos > it->

) {

->thick_backbone[it->

].payload.overflow_cursor;

subject_from,

subject_to,

q = query_from;

num_extensions = 0;

word_size = 12;

big_word_size = 0;

scan_from = subject_from;

= (1U << (2 * word_size)) - 1;

best_score = 0;

num_matches = 0;

is_right = subject_from < subject_to;

big_word_size =

(

(query_len - query_from - 5, word_size), 24);

scan_step = big_word_size - word_size + 1;

big_word_size =

(

(query_from - 5, word_size), 24);

scan_step = -(big_word_size - word_size + 1);

((is_right && (query_len - query_from + 1 < big_word_size ||

scan_to - subject_from < big_word_size)) ||

(!is_right && (query_from < big_word_size ||

subject_from - scan_to < big_word_size))) {

(; q + big_word_size < query_len && num_words <

; q++) {

(q + big_word_size <= query_len) {

(

= 0;

< big_word_size;

++) {

((query_seq[q +

] & 0xfc) != 0) {

(

== big_word_size) {

(q + big_word_size - 1 >= query_len) {

word[num_words] = (query_seq[q] << 6) | (query_seq[q + 1] << 4) |

(query_seq[q + 2] << 2) | query_seq[q + 3];

(

= 4;

< word_size;

++) {

word[num_words] = (word[num_words] << 2) | query_seq[q +

];

(word[num_words] == 0 || word[num_words] == 0xffffff) {

query_pos[num_words] = q;

(

= 0;

< big_word_size;

++) {

((query_seq[q +

] & 0xfc) != 0) {

q = q - big_word_size +

;

(

== big_word_size) {

word[num_words] = (query_seq[q] << 6) | (query_seq[q + 1] << 4) |

(query_seq[q + 2] << 2) | query_seq[q + 3];

(

= 4;

< word_size;

++) {

word[num_words] = (word[num_words] << 2) | query_seq[q +

];

(word[num_words] == 0 || word[num_words] == 0xffffff) {

query_pos[num_words] = q;

(num_words == 0) {

(

= scan_from; (scan_from < scan_to &&

< scan_to) ||

(scan_from > scan_to &&

> scan_to);

+= scan_step) {

local_ungapped_ext;

(num_matches > kMaxNumMatches) {

w = (

)s[0] << 16 | s[1] << 8 | s[2];

(; last_idx < num_bytes; last_idx++) {

w = w << 8 | s[last_idx];

w = (w << 8) | s[last_idx];

index = (w >> shift) &

;

(k = 0;k < num_words; k++) {

(index == word[k]) {

(k >= num_words) {

q_offset = query_pos[k];

(k = word_size;k < big_word_size;k++) {

(k < big_word_size) {

&local_ungapped_ext);

(gap_align->

<= best_score) {

best_score = gap_align->

;

query_info, gap_align,

,

score_params, hit_params);

(hsp->

>= query_len - query_from) {

(!

|| !

|| !query_info || !gap_align || !score_params ||

!hit_params || !hsp_stream) {

hsp_list->

, word_size);

(ch = chains; ch; ch = ch->

) {

query_info, gap_align, score_params,

hit_params, hsp_list);

query_info, gap_align, score_params,

hit_params, hsp_list);

(h = ch->

; h; h = h->

) {

(

=0;

< length - 1;

++) {

base_1 = sequence[

];

base_2 = sequence[

+ 1];

((base_1 & 0xfc) == 0 && (base_2 & 0xfc) == 0) {

dimer = (base_1 << 2) | base_2;

sum += (double)counts[

] *

((

)counts[

] / num);

-sum * (1.0 /(

(16.0))) + 0.5;

kMaxFractionOfAmbiguousBases = options->

;

(

= 0;

< length;

++) {

(sequence[

] & 0xfc) {

((

)num / length > kMaxFractionOfAmbiguousBases) {

(entropy <= options->entropy) {

(query_length <= 20) {

query_length;

(query_length <= 34) {

(query_length < 200) {

(

)(0.6 * query_length);

#define COMPRESSION_RATIO

Compression ratio of nucleotide bases (4 bases in 1 byte)

#define sfree(x)

Safe free a pointer: belongs to a higher level header.

Private interface for blast_gapalign.c.

Structures and API used for saving BLAST hits.

Int2 Blast_HSPInit(Int4 query_start, Int4 query_end, Int4 subject_start, Int4 subject_end, Int4 query_gapped_start, Int4 subject_gapped_start, Int4 query_context, Int2 query_frame, Int2 subject_frame, Int4 score, GapEditScript **gap_edit, BlastHSP **ret_hsp)

Allocates BlastHSP and inits with information from input.

BlastHSPList * Blast_HSPListNew(Int4 hsp_max)

Creates HSP list structure with a default size HSP array.

BlastHSPMappingInfo * BlastHSPMappingInfoNew(void)

Allocate memory for an HSP's additional data structure.

BlastHSP * Blast_HSPFree(BlastHSP *hsp)

Deallocate memory for an HSP structure.

Int2 Blast_HSPListSaveHSP(BlastHSPList *hsp_list, BlastHSP *hsp)

Saves HSP information into a BlastHSPList structure.

BlastHSPList * Blast_HSPListFree(BlastHSPList *hsp_list)

Deallocate memory for an HSP list structure as well as all it's components.

int BlastHSPStreamWrite(BlastHSPStream *hsp_stream, BlastHSPList **hsp_list)

Invokes the user-specified write function for this BlastHSPStream implementation.

#define BLASTERR_MEMORY

System error: out of memory condition.

Routines for creating nucleotide BLAST lookup tables.

Int4 BlastNaLookupTableNew(BLAST_SequenceBlk *query, BlastSeqLoc *locations, BlastNaLookupTable **lut, const LookupTableOptions *opt, const QuerySetUpOptions *query_options, Int4 lut_width)

Create a new nucleotide lookup table.

#define NA_HITS_PER_CELL

maximum number of hits in one lookup table cell

BlastNaLookupTable * BlastNaLookupTableDestruct(BlastNaLookupTable *lookup)

Free a nucleotide lookup table.

@ eMBLookupTable

megablast lookup table (includes both contiguous and discontiguous megablast)

Int4 BSearchContextInfo(Int4 n, const BlastQueryInfo *A)

Search BlastContextInfo structures for the specified offset.

ncbi::TMaskedQueryRegions mask

static void DLIST_NAME() append(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static int lookup(const char *name, const struct lookup_int *table)

void GapPrelimEditBlockAdd(GapPrelimEditBlock *edit_block, EGapAlignOpType op_type, Int4 num_ops)

Add a new operation to a preliminary edit block, possibly combining it with the last operation if the...

EGapAlignOpType

Operation types within the edit script.

@ eGapAlignIns

Insertion: a gap in subject.

@ eGapAlignSub

Substitution.

@ eGapAlignDel

Deletion: a gap in query.

GapEditScript * GapEditScriptNew(Int4 size)

Initialize the edit script structure.

GapEditScript * GapEditScriptDelete(GapEditScript *esp)

Free edit script structure.

uint8_t Uint1

1-byte (8-bit) unsigned integer

int16_t Int2

2-byte (16-bit) signed integer

int32_t Int4

4-byte (32-bit) signed integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

#define MT_LOCK_Do(lk, how)

Call "lk->handler(lk->data, how)".

@ eMT_Unlock

unlock critical section

@ eMT_Lock

lock critical section

unsigned int

A callback function used to compare two keys in a database.

Implementation of a number of BlastHSPWriters to save the best chain of RNA-Seq hits to a genome.

HSPChain * FindPartialyCoveredQueries(void *data, Int4 oid, Int4 word_size)

Find HSP chains that do not cover full extend of queries for a given subject.

<!DOCTYPE HTML >< html > n< header > n< title > PubSeq Gateway Help Page</title > n< style > n table

static int s_GetSeqPositions(JumperPrelimEditBlock *edit_script, Int4 edit_index, Int4 *query_pos, Int4 *subject_pos)

static JumperPrelimEditBlock * JumperPrelimEditBlockFree(JumperPrelimEditBlock *block)

Int4 BlastNaExtendJumper(BlastOffsetPair *offset_pairs, Int4 num_hits, const BlastInitialWordParameters *word_params, const BlastScoringParameters *score_params, const BlastHitSavingParameters *hit_params, LookupTableWrap *lookup_wrap, BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, BlastQueryInfo *query_info, BlastGapAlignStruct *gap_align, BlastHSPList *hsp_list, Uint4 s_range, SubjectIndex *s_index)

Extend a list of word hits.

Int4 JumperExtendLeft(const Uint1 *query, const Uint1 *subject, Int4 query_offset, Int4 subject_offset, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, int max_mismatches, int window, int *query_ext_len, int *subject_ext_len, GapPrelimEditBlock *edit_script)

static BlastHSP * s_CreateHSPForWordHit(Int4 q_offset, Int4 s_offset, Int4 length, Int4 context, const Uint1 *query, const BlastQueryInfo *query_info, const BLAST_SequenceBlk *subject, Int4 query_len)

int JumperGappedAlignmentCompressedWithTraceback(const Uint1 *query, const Uint1 *subject, Int4 query_length, Int4 subject_length, Int4 query_start, Int4 subject_start, BlastGapAlignStruct *gap_align, const BlastScoringParameters *score_params, Int4 *num_identical, Int4 *right_ungapped_ext_len)

Jumper gapped alignment with traceback; 1 base per byte in query, 4 bases per byte in subject.

JumperEditsBlock * JumperEditsBlockFree(JumperEditsBlock *block)

SequenceOverhangs * SequenceOverhangsFree(SequenceOverhangs *overhangs)

int JumperFindSpliceSignals(BlastHSP *hsp, Int4 query_len, const Uint1 *subject, Int4 subject_len)

Find splice signals at the edges of an HSP and save them in the HSP.

#define UNPACK_BASE(seq, pos)

JumperGapAlign * JumperGapAlignNew(Int4 size)

static int s_ShiftGapsRight(JumperPrelimEditBlock *edit_script, const Uint1 *query, const Uint1 *subject, Int4 query_offset, Int4 subject_offset, Int4 query_length, Int4 subject_length, Int4 *score, Int4 err_score, Int4 *num_identical)

SubjectIndexIterator * SubjectIndexIteratorNew(SubjectIndex *s_index, Int4 word, Int4 from, Int4 to)

Create an iterator for locations of a given word.

Int4 SubjectIndexIteratorPrev(SubjectIndexIterator *it)

Return the previous location of a word in an indexed sequence.

Int4 JumperExtendRight(const Uint1 *query, const Uint1 *subject, int query_length, int subject_length, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, int max_mismatches, int window, int *query_ext_len, int *subject_ext_len, GapPrelimEditBlock *edit_script, Boolean left_extension)

static Int2 s_MaskSequence(Int4 offset, Int4 length, BlastSeqLoc **seq_locs)

static int s_ShiftGaps(BlastGapAlignStruct *gap_align, const Uint1 *query, const Uint1 *subject, Int4 query_length, Int4 subject_length, Int4 err_score, Int4 *num_identical)

static Int4 s_SaveSubjectOverhangs(BlastHSP *hsp, Uint1 *subject, Int4 query_len)

static void s_ResetJumperPrelimEditBlocks(JumperPrelimEditBlock *left, JumperPrelimEditBlock *right)

static Int4 s_ComputeExtensionScore(JumperPrelimEditBlock *edit_script, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score)

JumperEditsBlock * JumperEditsBlockCombine(JumperEditsBlock **block_ptr, JumperEditsBlock **append_ptr)

Int4 JumperPrelimEditBlockAdd(JumperPrelimEditBlock *block, JumperOpType op)

JumperGapAlign * JumperGapAlignFree(JumperGapAlign *jgap_align)

static Int4 s_FindDimerEntropy(Uint1 *sequence, Int4 length)

GapEditScript * GapEditScriptCombine(GapEditScript **edit_script_ptr, GapEditScript **append_ptr)

Int4 JumperExtendLeftCompressedWithTraceback(const Uint1 *query, const Uint1 *subject, Int4 query_offset, Int4 subject_offset, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, int max_mismatches, int window, Uint4 *table, Int4 *query_ext_len, Int4 *subject_ext_len, JumperPrelimEditBlock *edit_script, Int4 *num_identical, JUMP *jumper)

JumperEditsBlock * JumperEditsBlockNew(Int4 num)

Boolean JumperGoodAlign(const BlastGapAlignStruct *gap_align, const BlastHitSavingParameters *hit_params, Int4 num_identical, BlastContextInfo *context_info)

Test whether an HSP should be saved.

SubjectIndex * SubjectIndexNew(BLAST_SequenceBlk *subject, Int4 width, Int4 word_size)

Index a sequence, used for indexing compressed nucleotide subject sequence.

Int4 JumperExtendLeftCompressedWithTracebackOptimal(const Uint1 *query, const Uint1 *subject, Int4 query_offset, Int4 subject_offset, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, int max_mismatches, int window, Int4 x_drop, Uint4 *table, Int4 *query_ext_len, Int4 *subject_ext_len, JumperPrelimEditBlock *edit_script, Int4 *best_num_identical)

Int2 DoAnchoredSearch(BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 word_size, BlastQueryInfo *query_info, BlastGapAlignStruct *gap_align, const BlastScoringParameters *score_params, const BlastHitSavingParameters *hit_params, BlastHSPStream *hsp_stream)

Do a search against a single subject with smaller word size and with no database word frequency filte...

static JumperPrelimEditBlock * JumperPrelimEditBlockNew(Int4 size)

Int4 JumperExtendRightCompressedWithTraceback(const Uint1 *query, const Uint1 *subject, int query_length, int subject_length, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, int max_mismatches, int window, Uint4 *table, Int4 *query_ext_len, Int4 *subject_ext_len, JumperPrelimEditBlock *edit_script, Int4 *num_identical, Boolean left_extension, Int4 *ungapped_ext_len, JUMP *jumper)

SubjectIndexIterator * SubjectIndexIteratorFree(SubjectIndexIterator *it)

Free memory reserved for subject index word iterator.

static Int4 DoAnchoredScan(Uint1 *query_seq, Int4 query_len, Int4 query_from, Int4 context, BLAST_SequenceBlk *subject, Int4 subject_from, Int4 subject_to, BlastQueryInfo *query_info, BlastGapAlignStruct *gap_align, const BlastScoringParameters *score_params, const BlastHitSavingParameters *hit_params, BlastHSPList *hsp_list)

Int4 JumperExtendRightCompressed(const Uint1 *query, const Uint1 *subject, int query_length, int subject_length, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, int max_mismatches, int window, Uint4 *table, Int4 *query_ext_len, Int4 *subject_ext_len, Int4 *num_identical, Int4 *ungapped_ext_len)

Int4 JumperExtendRightCompressedWithTracebackOptimal(const Uint1 *query, const Uint1 *subject, int query_length, int subject_length, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, int max_mismatches, int window, Int4 x_drop, Uint4 *table, Int4 *query_ext_len, Int4 *subject_ext_len, JumperPrelimEditBlock *edit_script, Int4 *best_num_identical, Boolean left_extension, Int4 *ungapped_ext_len)

SubjectIndex * SubjectIndexFree(SubjectIndex *sindex)

Free subject index structure.

static int s_CompareOffsetPairsByDiagQuery(const void *a, const void *b)

JumperEditsBlock * JumperFindEdits(const Uint1 *query, const Uint1 *subject, BlastGapAlignStruct *gap_align)

Int2 FilterQueriesForMapping(Uint1 *sequence, Int4 length, Int4 offset, const SReadQualityOptions *options, BlastSeqLoc **seq_loc)

Int4 JumperExtendLeftCompressed(const Uint1 *query, const Uint1 *subject, Int4 query_offset, Int4 subject_offset, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, int max_mismatches, int window, Uint4 *table, Int4 *query_ext_len, Int4 *subject_ext_len, Int4 *num_identical)

#define JUMPER_EDIT_BLOCK_ADD(block, op)

JumperEditsBlock * JumperEditsBlockDup(const JumperEditsBlock *block)

GapEditScript * JumperPrelimEditBlockToGapEditScript(JumperPrelimEditBlock *rev_prelim_block, JumperPrelimEditBlock *fwd_prelim_block)

Convert Jumper's preliminary edit script to GapEditScript.

static BlastHSP * s_CreateHSP(Uint1 *query_seq, Int4 query_len, Int4 context, BlastQueryInfo *query_info, BlastGapAlignStruct *gap_align, BLAST_SequenceBlk *subject, const BlastScoringParameters *score_params, const BlastHitSavingParameters *hit_params)

Int4 SubjectIndexIteratorNext(SubjectIndexIterator *it)

Return the next location of a word in an indexed sequence.

static void s_CreateTable(Uint4 *table)

static void s_TrimExtension(JumperPrelimEditBlock *jops, int margin, const Uint1 **cp, Int4 *cq, Int4 *num_identical, Boolean is_right_ext)

Int4 GetCutoffScore(Int4 query_length)

Get alignment cutoff score for a given query length.

static void s_SubjectIndexNewCleanup(BLAST_SequenceBlk *sequence, BlastSeqLoc *seqloc, LookupTableOptions *opt, QuerySetUpOptions *query_opt, SubjectIndex *sindex)

Int4 JumperExtendRightWithTraceback(const Uint1 *query, const Uint1 *subject, int query_length, int subject_length, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, int max_mismatches, int window, Int4 *query_ext_len, Int4 *subject_ext_len, JumperPrelimEditBlock *edit_script, Int4 *num_identical, Boolean left_extension, Int4 *ungapped_ext_len, JUMP *jumper)

Right extension with traceback.

Int2 JumperOpType

Jumper edit script operation.

#define SUBJECT_INDEX_WORD_LENGTH

const struct ncbi::grid::netcache::search::fields::SIZE size

#define MIN(a, b)

returns smaller of a and b.

Uint1 Boolean

bool replacment for C

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

#define ASSERT

macro for assert.

#define MAX(a, b)

returns larger of a and b.

static SLJIT_INLINE sljit_ins st(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

HSPChain * HSPChainFree(HSPChain *chain_list)

Deallocate a chain or list of chains.

Structure to hold a sequence.

Uint1 * sequence

Sequence used for search (could be translation).

The context related information.

Int4 query_length

Length of this query, strand or frame.

Int4 query_offset

Offset of this query, strand or frame in the concatenated super-query.

Int1 frame

Frame number (-1, -2, -3, 0, 1, 2, or 3)

Structure supporting the gapped alignment.

Int4 gap_x_dropoff

X-dropoff parameter to use.

Int4 query_stop

query end offseet of current alignment

Int4 subject_start

subject start offset current alignment

Int4 query_start

query start offset of current alignment

Int4 subject_stop

subject end offset of current alignment

Int4 max_mismatches

Max number of mismatches for jumper.

Int4 mismatch_window

Window sie for mismatches for jumper.

JumperGapAlign * jumper

data for jumper alignment

Int4 score

Return value: alignment score.

GapEditScript * edit_script

The traceback (gap) information.

The structure to hold all HSPs for a given sequence after the gapped alignment.

Int4 oid

The ordinal id of the subject sequence this HSP list is for.

Uint1 left_edge

Two subject bases before the alignment in the four least significant bits and flags in most significa...

JumperEditsBlock * edits

Information about mismatches and gaps, used for mapping short reads.

SequenceOverhangs * subject_overhangs

Unaligned subject subsequence.

Default implementation of BlastHSPStream.

BlastHSPWriter * writer

writer to be applied when writing

MT_LOCK x_lock

Mutex for writing and reading results.

void * data

data structure

Structure holding all information about an HSP.

double evalue

This HSP's e-value.

Int4 num_ident

Number of identical base pairs in this HSP.

BlastSeg query

Query sequence info.

Int4 context

Context number of query.

BlastSeg subject

Subject sequence info.

Int4 score

This HSP's raw score.

BlastHSPMappingInfo * map_info

Int4 longest_intron

The longest distance between HSPs allowed for combining via sum statistics with uneven gaps.

Int4 cutoff_score

The (raw) score cut-off threshold.

Int4 max_edit_distance

Maximum number of mismatches and gaps.

Int4 cutoff_score_fun[2]

Coefficients x100 for the raw score cut-off threshold as a function of query length: x[0] + x[1] * qu...

double percent_identity

The percent identity cut-off threshold.

Parameter block that contains a pointer to BlastHitSavingOptions and the values derived from it.

BlastHitSavingOptions * options

The original (unparsed) options.

Parameter block that contains a pointer to BlastInitialWordOptions and the values derived from it.

The lookup table structure used for Mega BLAST.

Int4 lut_word_length

number of letters in a lookup table word

Int4 word_length

number of exact letter matches that will trigger an ungapped extension

The basic lookup table structure for blastn searches.

Int4 lut_word_length

Length in bases of a word indexed by the lookup table.

Int4 word_length

Length in bases of the full word match required to trigger extension.

The query related information.

BlastContextInfo * contexts

Information per context.

int num_queries

Number of query sequences.

Scoring parameters block Contains scoring-related information that is actually used for the blast sea...

Int4 gap_extend

Penalty for each gap residue (scaled version)

Int2 penalty

Penalty for a mismatch.

Int4 gap_open

Extra penalty for starting a gap (scaled version)

Int2 reward

Reward for a match.

Int4 offset

Start of hsp.

Used to hold a set of positions, mostly used for filtering.

SSeqRange * ssr

location data on the sequence.

struct BlastSeqLoc * next

next in linked list

Edit script: linked list of correspondencies between two sequences.

Int4 * num

Array of number of operations.

Int4 size

Size of above arrays.

EGapAlignOpType * op_type

Array of type of operation.

Preliminary version of GapEditBlock, used directly by the low- level dynamic programming routines.

A chain of HSPs: spliced alignment.

HSPContainer * hsps

A list of HSPs that belong to this chain.

struct HSPChain * next

Pointer to the next chain in a list.

struct HSPContainer * next

Alignment edit script for gapped alignment.

Gapped alignment data needed for jumper.

JumperPrelimEditBlock * left_prelim_block

Uint4 * table

Table used for matching 4 bases in compressed subject to 4 bases in uncompressed query.

JumperPrelimEditBlock * right_prelim_block

Internal alignment edit script.

Options needed to construct a lookup table Also needed: query sequence and query length.

Int4 word_size

Determines the size of the lookup table.

Wrapper structure for different types of BLAST lookup tables.

void * lut

Pointer to the actual lookup table structure.

ELookupTableType lut_type

What kind of a lookup table it is?

Options required for setting up the query sequence.

Filtering options for mapping next-generation sequences.

double frac_ambig

Fraction of ambiguous bases.

A structure containing two integers, used e.g.

Int4 left

left endpoint of range (zero based)

Int4 right

right endpoint of range (zero based)

Structure to save short unaligned subsequences outside an HSP.

Uint1 * left

Left subsequence.

Uint1 * right

Rught subsequence.

Int4 right_len

Length of the right subsequence.

Int4 left_len

Length of the left subsequence.

Iterator over word locations in subject index.

SubjectIndex * subject_index

Index for a chunk of a subject sequence.

Int4 num_lookups

Number of lookup tables used.

Int4 width

Number of bases covered by each lookup table.

BlastNaLookupTable ** lookups

Array of lookup tables.

This symbol enables the verbose option in makeblastdb and other BLAST+ search command line applicatio...

Uint4 q_off

Query offset.

Uint4 s_off

Subject offset.

struct BlastOffsetPair::@6 qs_offsets

Query/subject offset pair.

static CS_CONTEXT * context

voidp calloc(uInt items, uInt size)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4