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

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

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

prelim_hitlist_size = hitlist_size;

* ADAPTIVE_CBS_ENV = getenv(

);

(compositionBasedStats) {

(ADAPTIVE_CBS_ENV !=

) {

(hitlist_size < 1000) {

prelim_hitlist_size =

(prelim_hitlist_size + 1000, 1500);

prelim_hitlist_size = prelim_hitlist_size*2 + 50;

(hitlist_size <= 500) {

prelim_hitlist_size = 1050;

prelim_hitlist_size = prelim_hitlist_size*2 + 50;

(gapped_calculation) {

prelim_hitlist_size =

(

(2 * prelim_hitlist_size, 10), prelim_hitlist_size + 50);

prelim_hitlist_size;

(hit_options ==

||

ext_options ==

||

scoring_options ==

)

subject_end,

query_gapped_start,

subject_gapped_start,

query_context,

(new_hsp ==

)

new_hsp->

= query_context;

new_hsp->

= score;

(gap_edit && *gap_edit)

(

->subject_overhangs) {

new_hsp->

= hsp->

;

retval->

= hsp->

;

(!

->right) {

lastEffectiveOccurrence;

min_pattern_length;

(index = 1; index < pat_info->

; ++index) {

> min_pattern_length) {

(query_info && hsp && sbp && pattern_blk);

exp(-Lambda*hsp->

);

score,

* query_start,

* subject_start,

* best_q_start,

* best_q_end,

* best_s_start,

* best_s_end,

best_start_esp_index,

best_end_esp_index,

best_end_esp_num)

(hsp->

>= cutoff_score) {

(best_end_esp_index != last_num|| best_start_esp_index > 0)

hsp->

->

[last_num] = best_end_esp_num;

(best_end_esp_num >= 0);

sum, score, gap_open, gap_extend;

best_start_esp_index = 0;

best_end_esp_index = 0;

current_start_esp_index = 0;

best_end_esp_num = 0;

* best_q_start;

* best_s_start;

* best_q_end;

* best_s_end;

* current_q_start;

* current_s_start;

kResidueMask = 0x0f;

(score_params->

% 2 == 1)

(score_params->

- 2*score_params->

) * factor / 2;

gap_open = score_params->

;

best_q_start = best_q_end = current_q_start =

;

best_s_start = best_s_end = current_s_start =

;

best_end_esp_num = -1;

(!esp)

;

(index=0; index<esp->

; index++)

(op_index=0; op_index<esp->

[index]; )

sum += factor*matrix[*

& kResidueMask][*

];

sum -= gap_open + gap_extend * esp->

[index];

op_index += esp->

[index];

sum -= gap_open + gap_extend * esp->

[index];

op_index += esp->

[index];

(op_index < esp->num[index]) {

esp->

[index] -= op_index;

current_start_esp_index = index;

current_start_esp_index = index + 1;

current_q_start =

;

(score < cutoff_score) {

best_q_start =

;

best_start_esp_index = current_start_esp_index;

best_end_esp_index = current_start_esp_index;

}

(sum > score) {

best_q_start = current_q_start;

best_s_start = current_s_start;

best_start_esp_index = current_start_esp_index;

best_end_esp_index = index;

best_end_esp_num = op_index;

(best_start_esp_index < esp->

&& best_end_esp_index < esp->

) {

qp = (

)(best_q_start - q);

sp = (

)(best_s_start - s);

(qp > 0 && sp > 0 && (q[--qp] == s[--sp]) && q[qp]<4) ext++;

esp->

[best_start_esp_index] += ext;

(best_end_esp_index == best_start_esp_index) best_end_esp_num += ext;

score += ext * score_params->

;

qp = (

)(best_q_end - q);

sp = (

)(best_s_end - s);

(qp < qlen && sp < slen && q[qp]<4 && (q[qp++] == s[sp++])) ext++;

esp->

[best_end_esp_index] += ext;

best_end_esp_num += ext;

score += ext * score_params->

;

score, q, s, best_q_start,

best_q_end, best_s_start, best_s_end,

best_start_esp_index, best_end_esp_index,

* query_start,

* subject_start,

* best_q_start,

* best_q_end,

* best_s_start,

* best_s_end)

subject_start, best_q_start, best_q_end,

best_s_start, best_s_end, 0, 0, 0);

* best_q_start,* best_s_start,* best_q_end,* best_s_end;

* current_q_start, * current_s_start;

kResidueMask = (translated ? 0xff : 0x0f);

best_q_start = best_q_end = current_q_start =

;

best_s_start = best_s_end = current_s_start =

;

(index = 0; index < hsp_length; ++index) {

current_q_start =

;

(score < cutoff_score) {

best_q_start = best_q_end =

;

best_s_start = best_s_end =

;

}

(sum > score) {

best_q_start = current_q_start;

best_s_start = current_s_start;

query_start, subject_start, best_q_start,

best_q_end, best_s_start, best_s_end);

, num_ident, align_length, q_off, s_off;

(q_length != s_length)

align_length = q_length;

(

=0;

<align_length;

++) {

(

!= matrix) {

(matrix[*q][*s] > 0)

(index=0; index<esp->

; index++)

align_length += esp->

[index];

(esp->

[index]) {

(

=0;

<esp->

[index];

++) {

(

!= matrix) {

(matrix[*q][*s] > 0)

s += esp->

[index];

q += esp->

[index];

s += esp->

[index];

q += esp->

[index];

(align_length_ptr) {

*align_length_ptr = align_length;

*num_ident_ptr = num_ident;

*num_pos_ptr = num_pos + num_ident;

* num_ident_ptr,

* align_length_ptr,

num_ident, align_length;

(index=0; index<esp->

; index++)

(esp->

[index]) {

align_length += esp->

[index];

(

=0;

<esp->

[index];

++) {

(

!= matrix) {

(matrix[*q][*s] > 0)

align_length += esp->

[index];

align_length += esp->

[index];

q += esp->

[index];

q += esp->

[index];

(align_length_ptr) {

*align_length_ptr = align_length;

*num_ident_ptr = num_ident;

*num_pos_ptr = num_pos + num_ident;

* align_length_ptr)

* align_length_ptr,

align_length < hit_options->min_hit_length) ;

align_length = 0;

delete_hsp =

(hsp, hit_options, align_length);

(hsp, hit_options, align_length);

(query_length > 0) {

pct = 100.0 * (double) (hsp->

.

- hsp->

.

)/ (double) query_length;

min_query_coverage_pct,

(hsp_coverage < min_query_coverage_pct);

* gaps_out,

* gap_opens_out)

gap_opens = 0, gaps = 0;

(index=0; index<esp->

; index++) {

length += esp->

[index];

gaps += esp->

[index];

gaps += esp->

[index];

}

(s_length > length) {

*length_out = length;

*gap_opens_out = gap_opens;

(segment->

< 0) {

}

(segment->

> 0) {

*start = segment->

+ 1;

*end = segment->

;

query_length,

subject_length,

(target_t->

&& (start ||

(stop < target_t->subject_blk->length /

-3)))

kMaxTranslation = 99;

nucl_length = 0;

translation_length = 0;

nucl_start = 0;

nucl_shift = 0;

start_shift = 0;

nucl_length = nucl_end - nucl_start;

nucl_shift = nucl_start;

(start_shift < start || start_shift+translation_length > stop) {

(translation_length > stop-start) {

target_t->

[2*

+1] = start_shift + length;

(nucl_seq_rev);

(translated_length)

* gen_code_string,

** translation_buffer_ptr,

** subject_ptr,

* subject_length_ptr,

* start_shift_ptr)

translation_length;

* translation_buffer;

(subject_blk && hsp && gen_code_string && translation_buffer_ptr &&

subject_ptr && subject_length_ptr && start_shift_ptr);

translation_buffer = *translation_buffer_ptr;

(translation_buffer);

translation_length =

subject_blk->

) - start_shift;

nucl_shift = start_shift;

nucl_shift = subject_blk->

- start_shift - translation_length;

gen_code_string, &translation_buffer,

subject_length_ptr,

);

oof_end = subject_blk->

;

translation_length =

nucl_shift = start_shift;

nucl_shift = oof_end - start_shift - translation_length;

gen_code_string,

,

subject_length_ptr, &translation_buffer);

*translation_buffer_ptr = translation_buffer;

*start_shift_ptr = start_shift;

= translation_buffer + 1;

(start_shift > 0) {

(!hsp_list || hsp_list->

<= 1)

(index = 0; index < hsp_list->

- 1; ++index) {

(!hsp_list || hsp_list->

<= 1)

= 1.0e-180;

(evalue1 < evalue2) {

}

(evalue1 > evalue2) {

(hsp_list->

> 1) {

(index = 0; index < hsp_list->

- 1; ++index) {

(index < hsp_list->hspcnt - 1) {

score_density = (hsp1->

+ hsp2->

) *(1.0) /

(index = 0; index < hsp_list->

; ++index) {

kDefaultAllocated=100;

num = hsp_list->

;

(index = 0; index < hsp_list->

; ++index) {

(

* base0,

* base,

* lim,

*

,

width,

(*compar )(

*,

* ))

* left_son,* large_son;

left_son = base0 + 2*(base-base0) + width;

(base <= lim) {

(left_son ==

)

large_son = left_son;

large_son = (*compar)(left_son, left_son+width) >= 0 ?

left_son : left_son+width;

((*compar)(base, large_son) < 0) {

(

=0;

<width; ++

) {

base[

] = large_son[

];

large_son[

] = ch;

left_son = base0 + 2*(base-base0) + width;

(*compar )(

*,

* ))

* base = (

*)

;

* base0 = (

*)base,* lim,* basef;

lim = &base[((nel-2)/2)*width];

basef = &base[(nel-1)*width];

(base = &base0[(

- 1)*width];

> 0; base = base - width) {

(base0, base, lim, basef, width, compar);

hsp_array[0] = *hsp;

(hsp_list->

>= 2) {

((

*)hsp_array, (

*)hsp_array,

(

*)&hsp_array[hsp_list->

/2 - 1],

(

*)&hsp_array[hsp_list->

-1],

best_evalue = (double)

;

kDelta = 1.0e-200;

(hsp_list->

== 0)

(index=0; index<hsp_list->

; index++)

(

(best_evalue-hsp_list->

)/(best_evalue+kDelta) > 0.01)

best_evalue = (double)

;

(index=0; index<hsp_list->

; index++)

hspcnt = hsp_list->

;

(new_allocated > hsp_list->

) {

realloc(hsp_array, new_allocated*

(

*));

(hsp_array ==

)

hsp_allocated = new_allocated;

(hspcnt < hsp_allocated)

hsp_array[hsp_list->

] = new_hsp;

subject_length,

scaling_factor)

gap_decay_divisor = 1.;

(hsp_list ==

|| hsp_list->

== 0)

kbp = (gapped_calculation ? sbp->

: sbp->

);

hsp_cnt = hsp_list->

;

(gap_decay_rate != 0.)

(index=0; index<hsp_cnt; index++) {

hsp = hsp_array[index];

(scaling_factor != 0.0);

(kbp[

])

;

(kbp[kbp_context]);

kbp[kbp_context]->

/= scaling_factor;

score = hsp->

;

(hsp_list && hsp_list->

!= 0

&& gapped_calculation && sbp->

) {

hsp->

/= gap_decay_divisor;

kbp[kbp_context]->

*= scaling_factor;

(hsp_list ==

)

kbp = (gapped_calculation ? sbp->

: sbp->

);

(index=0; index<hsp_list->

; index++) {

(index=0; index<hsp_list->

; index++) {

(!hsp_list || hsp_list->

== 0)

(index = 0; index < hsp_list->

; ++index) {

(hsp_list ==

)

(index = 0; index < hsp_list->

; index++) {

hsp = hsp_array[index];

(hsp->

> cutoff) {

(index > hsp_cnt)

hsp_array[hsp_cnt] = hsp_array[index];

hsp_list->

= hsp_cnt;

(index = 0; index < hsp_list->

; index++) {

hsp = hsp_array[index];

(index > hsp_cnt)

hsp_array[hsp_cnt] = hsp_array[index];

hsp_list->

= hsp_cnt;

((hsp_list ==

) ||

(index = hsp_max; index < hsp_list->

; index++) {

hsp_list->

= hsp_max;

(hsp_list ==

)

(index = 0; index < hsp_list->

; index++) {

hsp = hsp_array[index];

(index > hsp_cnt)

hsp_array[hsp_cnt] = hsp_array[index];

hsp_list->

= hsp_cnt;

(*xx)->

- (*yy)->oid;

contexts_per_query,

*split_offsets,

(hitlist1 ==

)

(hitlist2 ==

) {

*combined_hit_list_ptr = hitlist1;

*old_hit_list_ptr =

;

(num_hsplists1 > 1) {

(num_hsplists2 > 1) {

query_is_split =

;

(

= 0;

< contexts_per_query;

++) {

(split_offsets[

] > 0) {

query_is_split =

;

(chunk_overlap_size != 0);

(

< num_hsplists1 && j < num_hsplists2) {

(hsplist1->

< hsplist2->

) {

(hsplist1->

> hsplist2->

) {

(query_is_split) {

hsplist2->

, split_offsets,

(;

< num_hsplists1;

++) {

(; j < num_hsplists2; j++) {

*old_hit_list_ptr =

;

*combined_hit_list_ptr = new_hitlist;

(hsp_list ==

|| hsp_list->

== 0)

hspcnt = hsp_list->

;

(index=0; index<hspcnt; index++)

(hsp_array[index] !=

)

hsp_array[index1] = hsp_array[index];

(index=index1; index<hspcnt; index++)

hsp_array[index] =

;

hsp_list->

= index1;

index, opid, qid, sid;

(index=0; index < esp->

; index++) {

(opid=0; opid < esp->

[index];){

sid+=esp->

[index];

opid+=esp->

[index];

qid+=esp->

[index];

opid+=esp->

[index];

(qid >= q_cut && sid >= s_cut) found =

;

(opid < esp->num[index]) {

esp->

[0] = esp->

[index] - opid;

(; index < esp->

; index++, new_index++) {

esp->

[new_index] = esp->

[index];

esp->

= new_index;

(opid < esp->num[index]) {

esp->

[index] = opid;

esp->

= index+1;

(hsp_list ==

|| hsp_list->

== 0)

hsp_list->

;

hsp_count = hsp_list->

;

(

< hsp_count) {

(

+j < hsp_count &&

hsp_array[

] && hsp_array[

+j] &&

hsp = hsp_array[

+j];

(k=

+j; k<hsp_count; k++) {

hsp_array[k] = hsp_array[k+1];

hsp_array[hsp_count] = hsp;

(

< hsp_count) {

(

+j < hsp_count &&

hsp_array[

] && hsp_array[

+j] &&

hsp = hsp_array[

+j];

(k=

+j; k<hsp_count; k++) {

hsp_array[k] = hsp_array[k+1];

hsp_array[hsp_count] = hsp;

curr_context, target_context;

(hsp_list ==

|| hsp_list->

== 0)

hsp_list->

;

(

=0; i < hsp_list->hspcnt -1;

++) {

(hsp_array[

] ==

){

e = hsp_array[

]->

.

+ range_diff;

(e < 0) e = hsp_array[

]->

.

;

(

+j < hsp_list->hspcnt) {

(hsp_array[

+j] && hsp_array[

]->

== hsp_array[

+j]->

&&

((hsp_array[

+j]->

.offset >= o) &&

(hsp_array[

+j]->

.

<= e))){

(

=0;

< hsp_list->

-1;

++) {

(hsp_array[

] ==

){

curr_context = hsp_array[

]->

;

target_context = (hsp_array[

]->

.

> 0) ? curr_context +1 : curr_context -1;

e = qlen - (hsp_array[

]->

.

- range_diff);

o = qlen - (hsp_array[

]->

.

+ range_diff);

(

+j < hsp_list->hspcnt) {

(hsp_array[

+j] && (hsp_array[

+j]->

== target_context) &&

(hsp_array[

+j]->

.end <= e))){

hsp_list->

;

* query_start;

hspcnt = hsp_list->

;

(hsp_list->

== 0)

(kNucleotideSubject)

memset((

*) &seq_arg, 0,

(seq_arg));

seq_arg.

= subject_blk->

;

seq_arg.

= subject_blk;

(index = 0; index < hspcnt; ++index) {

(status < 0){

(kTranslateSubject) {

(!gen_code_string)

subject_start = subject_blk->

;

(index = 0; index < hspcnt; ++index) {

(hsp_array[index] ==

)

hsp = hsp_array[index];

query_start = query_blk->

+

(kTranslateSubject)

(kNucleotideSubject) {

subject_start, word_params, sbp, kTranslateSubject);

align_length = 0;

index, index1, index2;

(new_hspcnt <= combined_hsp_list->allocated);

(new_hspcnt >= hsp_list->

+ combined_hsp_list->

) {

(index=combined_hsp_list->

, index1=0;

index1<hsp_list->hspcnt; index1++) {

combined_hsp_list->

= new_hspcnt;

index1 = index2 = 0;

(index = 0; index < new_hspcnt; ++index) {

(index1 < combined_hsp_list->hspcnt &&

(index2 >= hsp_list->

||

&hsp_list->

[index2]) <= 0)) {

new_hsp_array[index] = combined_hsp_list->

[index1];

new_hsp_array[index] = hsp_list->

[index2];

( ; index1 < combined_hsp_list->

; ++index1) {

combined_hsp_list->

[index1] =

( ; index2 < hsp_list->

; ++index2) {

combined_hsp_list->

= new_hsp_array;

combined_hsp_list->

= new_hspcnt;

* combined_hsp_list = *combined_hsp_list_ptr;

(!hsp_list || hsp_list->

== 0)

(!combined_hsp_list) {

*combined_hsp_list_ptr = hsp_list;

*old_hsp_list_ptr =

;

(new_hspcnt > combined_hsp_list->

&&

new_allocated =

(2*new_hspcnt, hsp_num_max);

new_allocated*

(

*));

(new_hsp_array) {

combined_hsp_list->

= new_allocated;

combined_hsp_list->

= new_hsp_array;

new_hspcnt = combined_hsp_list->

;

(combined_hsp_list->

== hsp_num_max)

*old_hsp_list_ptr =

;

hsp_num_max,

*split_offsets,

contexts_per_query,

chunk_overlap_size,

* combined_hsp_list = *combined_hsp_list_ptr;

index1, index2;

hspcnt1, hspcnt2, new_hspcnt = 0;

start_diag, end_diag;

(!hsp_list || hsp_list->

== 0)

(!combined_hsp_list) {

*combined_hsp_list_ptr = hsp_list;

*hsp_list_ptr =

;

hspcnt1 = hspcnt2 = 0;

(contexts_per_query < 0) {

(index1 = 0; index1 < combined_hsp_list->

; index1++) {

hsp1 = combined_hsp_list->

[index1];

(hsp1->

.

> split_offsets[0]) {

hsp_var = combined_hsp_list->

[hspcnt1];

combined_hsp_list->

[hspcnt1] = hsp1;

combined_hsp_list->

[index1] = hsp_var;

(index2 = 0; index2 < hsp_list->

; index2++) {

(hsp2->

.

< split_offsets[0] + chunk_overlap_size) {

hsp_var = hsp_list->

[hspcnt2];

hsp_list->

[index2] = hsp_var;

(index1 = 0; index1 < combined_hsp_list->

; index1++) {

hsp1 = combined_hsp_list->

[index1];

offset_idx = hsp1->

% contexts_per_query;

(split_offsets[offset_idx] < 0)

;

split_offsets[offset_idx]) ||

split_offsets[offset_idx] + chunk_overlap_size)) {

hsp_var = combined_hsp_list->

[hspcnt1];

combined_hsp_list->

[hspcnt1] = hsp1;

combined_hsp_list->

[index1] = hsp_var;

(index2 = 0; index2 < hsp_list->

; index2++) {

offset_idx = hsp2->

% contexts_per_query;

(split_offsets[offset_idx] < 0)

;

split_offsets[offset_idx]) ||

split_offsets[offset_idx] + chunk_overlap_size)) {

hsp_var = hsp_list->

[hspcnt2];

hsp_list->

[index2] = hsp_var;

(hspcnt1 > 0 && hspcnt2 > 0) {

(index1 = 0; index1 < hspcnt1; index1++) {

hsp1 = hspp1[index1];

(index2 = 0; index2 < hspcnt2; index2++) {

hsp2 = hspp2[index2];

(contexts_per_query < 0 || hsp1->

.frame >= 0) {

(new_hspcnt >= combined_hsp_list->

-1 &&

new_allocated =

(2*new_hspcnt, hsp_num_max);

(new_allocated > combined_hsp_list->

) {

new_allocated*

(

*));

(new_hsp_array ==

) {

combined_hsp_list->

= new_hsp_array;

combined_hsp_list->

= new_allocated;

new_hspcnt =

(new_hspcnt, combined_hsp_list->

);

*hsp_list_ptr =

;

(index=0; index<hsp_list->

; index++) {

(!hsp_list || hsp_list->

== 0 ||

gapped_calculation ==

||

(index = 0; index < hsp_list->

; ++index)

(h1->

== 0)

(h2->

== 0)

index, hsplist_count;

(index = 0; index < hsplist_count &&

( ; index < hsplist_count; ++index) {

kStartValue = 100;

evalue_order = 0;

(index =0; index < hit_list->

; index++) {

(evalue_order < 0) {

(index=0; index<hsplist_count; index++) {

(hsplist_array[index]) {

hsplist_array[index1] = hsplist_array[index];

(index=index1; index<hsplist_count; index++) {

hsplist_array[index] =

;

(index = 0; index <

->num_queries; ++index)

(index = 0; index <

->num_queries; ++index) {

hit_list =

->hitlist_array[index];

(hit_list !=

(index = 0; index <

->num_queries; ++index) {

hit_list =

->hitlist_array[index];

(index = 0; index <

->num_queries; ++index) {

hit_list =

->hitlist_array[index];

(index1 = 0; index1 < hit_list->

/2; ++index1) {

(

= 0;

<

->num_queries;

++) {

(hitlist ==

)

(j = hsp_count = 0; j < hitlist->

; j++) {

hsp_count += hsplist->

;

(m = 0; m < hsplist->

; k++, m++) {

hsp_array[k].

= hsplist;

hsp_array[k].

= hsp;

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

hsp, query_info, 0, masklevel)) {

(hsplist->

== 1)

(hsplist->

== 0) {

(!hsp_list || hsp_list->

== 0)

pattern_index, hit_index;

hit_list =

->hitlist_array[0];

(hit_index = 0; hit_index < hit_list->

; ++hit_index) {

(hsp_index = 0; hsp_index < hsp_list->

; ++hsp_index) {

(!hsplist_array[pattern_index])

hsplist_array[pattern_index]->

= hsp_list->

;

(pattern_index = 0; pattern_index < num_patterns;

(hsplist_array[pattern_index]) {

(!phi_results[pattern_index])

hsplist_array[pattern_index],

hsplist_array[pattern_index] =

;

(hsplist_array);

(pattern_index = 0; pattern_index < num_patterns; ++pattern_index) {

(

->hspcnt <

->hspcnt)

(

->hspcnt >

->hspcnt)

(total_hsp_limit == 0) {

hsp_limit_exceeded;

(query_index = 0; query_index <

->num_queries; ++query_index) {

hsplist_count = 0;

( !(hit_list =

->hitlist_array[query_index]) )

(subj_index = 0; subj_index < hsplist_count; ++subj_index) {

hsplist_array[subj_index] = hit_list->

[subj_index];

qsort((

*)hsplist_array, hsplist_count,

hsp_per_seq =

(1, total_hsp_limit/hsplist_count);

(subj_index = 0; subj_index < hsplist_count; ++subj_index) {

allowed_hsp_num = ((subj_index+1)*hsp_per_seq) - tot_hsps;

(hsp_list->

> allowed_hsp_num) {

(hsp_index = allowed_hsp_num;

hsp_index < hsp_list->

; ++hsp_index) {

hsp_list->

= allowed_hsp_num;

hsp_limit_exceeded =

;

tot_hsps += hsp_list->

;

(hsplist_array);

hsp_limit_exceeded;

(

->oid >

->oid);

total_hsp_limit,

(total_hsp_limit == 0) {

any_hsp_limit_exceeded;

(query_index = 0; query_index <

->num_queries; ++query_index) {

hsplist_count = 0;

total_hsps = 0;

( hsp_limit_exceeded) hsp_limit_exceeded[query_index] =

;

( !(hit_list =

->hitlist_array[query_index]) )

(subj_index = 0; subj_index < hsplist_count; ++subj_index) {

(total_hsps > total_hsp_limit)

hsp_counter = 0;

( hsp_limit_exceeded) {

hsp_limit_exceeded[query_index] =

;

any_hsp_limit_exceeded =

;

(subj_index = 0; subj_index < hsplist_count; ++subj_index) {

(subj_hsp=0; subj_hsp < subj_list->

; ++subj_hsp) {

everything_list[hsp_counter].

= hsps_per_subj[subj_hsp];

everything_list[hsp_counter].

= subj_list->

;

hsps_per_subj[subj_hsp] =

;

(hsp_counter = total_hsp_limit; hsp_counter < total_hsps ; ++hsp_counter) {

everything_list[hsp_counter].

=

(everything_list[hsp_counter].hsp);

everything_list[hsp_counter].

= 0x7fffff;

(hsp_counter = 0; hsp_counter < total_hsp_limit; ++ hsp_counter)

hsp_counter_start = hsp_counter;

((everything_list[hsp_counter].oid == everything_list[hsp_counter+1].oid) &&

(hsp_counter + 1 < total_hsp_limit)) {

num_hsp = hsp_counter -hsp_counter_start + 1;

subj_list->

= everything_list[hsp_counter].

;

(hspcnt = 0; hspcnt < num_hsp; ++hspcnt) {

(everything_list);

any_hsp_limit_exceeded;

*removed_hsps = rm_hsps;

*removed_hsps = rm_hsps;

Definitions used throughout BLAST.

#define sfree(x)

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

#define CODON_LENGTH

Codons are always of length 3.

#define BLAST_CMP(a, b)

A macro expression that returns 1, 0, -1 if a is greater than, equal to or less than b,...

#define NCBI_XBLAST_EXPORT

NULL operations for other cases.

BlastHSPResults * Blast_HSPResultsFromHSPStreamWithLimit(BlastHSPStream *hsp_stream, Uint4 num_queries, SBlastHitsParameters *hit_param, Uint4 max_num_hsps, Boolean *removed_hsps)

As Blast_HSPResultsFromHSPStream, except the total number of HSPs kept for each query does not exceed...

Int2 Blast_HSPListReapByRawScore(BlastHSPList *hsp_list, const BlastHitSavingOptions *hit_options)

Same as Blast_HSPListReapByEvalue() except that it uses the raw score of the hit and the HitSavingOpt...

Int2 Blast_HSPResultsReverseSort(BlastHSPResults *results)

Sort each hit list in the BLAST results by best e-value, in reverse order.

static void s_BlastHitListInsertHSPListInHeap(BlastHitList *hit_list, BlastHSPList *hsp_list)

Given a BlastHitList* with a heapified HSP list array, remove the worst scoring HSP list and insert t...

Int2 Blast_HSPListAppend(BlastHSPList **old_hsp_list_ptr, BlastHSPList **combined_hsp_list_ptr, Int4 hsp_num_max)

Append one HSP list to the other.

static int s_CompareHsplistHspcnt(const void *v1, const void *v2)

Comparison function for sorting HSP lists in increasing order of the number of HSPs in a hit.

void Blast_HSPListSortByEvalue(BlastHSPList *hsp_list)

Sort the HSPs in an HSP list by e-value, with scores and other criteria used to resolve ties.

static void s_BlastHitListPurge(BlastHitList *hit_list)

Purge a BlastHitList of empty HSP lists.

Int2 Blast_HitListHSPListsFree(BlastHitList *hitlist)

Deallocate memory for every HSP list on BlastHitList, as well as all their components.

static int s_CompareOidHSPwOid(const void *v1, const void *v2)

BlastHSP * Blast_HSPNew(void)

Allocate and zeros out memory for an HSP structure.

BlastHSPResults * Blast_HSPResultsFree(BlastHSPResults *results)

Deallocate memory for BLAST results.

static Int2 s_Blast_HSPGetOOFNumIdentitiesAndPositives(const Uint1 *query, const Uint1 *subject, const BlastHSP *hsp, EBlastProgramType program, Int4 *num_ident_ptr, Int4 *align_length_ptr, const BlastScoreBlk *sbp, Int4 *num_pos_ptr)

Calculate number of identities in an HSP for an out-of-frame alignment.

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.

void Blast_HSPListPHIGetEvalues(BlastHSPList *hsp_list, BlastScoreBlk *sbp, const BlastQueryInfo *query_info, const SPHIPatternSearchBlk *pattern_blk)

Calculate e-values for a PHI BLAST HSP list.

Int2 Blast_HSPGetNumIdentitiesAndPositives(const Uint1 *query, const Uint1 *subject, BlastHSP *hsp, const BlastScoringOptions *score_options, Int4 *align_length_ptr, const BlastScoreBlk *sbp)

Calculate number of identities and positives in an HSP and set the BlastHSP::num_ident and BlastHSP::...

static void s_CreateHeap(void *b, size_t nel, size_t width, int(*compar)(const void *, const void *))

Creates a heap of elements based on a comparison function.

static Boolean s_TrimResultsByTotalHSPLimitEx(BlastHSPResults *results, Uint4 total_hsp_limit, Boolean *hsp_limit_exceeded)

BlastHitList * Blast_HitListFree(BlastHitList *hitlist)

Deallocate memory for the hit list.

Int4 BlastHspNumMax(Boolean gapped_calculation, const BlastHitSavingOptions *options)

Calculated the number of HSPs that should be saved.

Int2 Blast_HitListMerge(BlastHitList **old_hit_list_ptr, BlastHitList **combined_hit_list_ptr, Int4 contexts_per_query, Int4 *split_offsets, Int4 chunk_overlap_size, Boolean allow_gap)

Combine two hitlists; both HitLists must contain HSPs that represent alignments to the same query seq...

static int s_EvalueCompareHSPs(const void *v1, const void *v2)

Comparison callback function for sorting HSPs by e-value and score, before saving BlastHSPList in a B...

Int2 Blast_HSPResultsSortByEvalue(BlastHSPResults *results)

Sort each hit list in the BLAST results by best e-value.

static Boolean s_UpdateReevaluatedHSP(BlastHSP *hsp, Boolean gapped, Int4 cutoff_score, Int4 score, const Uint1 *query_start, const Uint1 *subject_start, const Uint1 *best_q_start, const Uint1 *best_q_end, const Uint1 *best_s_start, const Uint1 *best_s_end, int best_start_esp_index, int best_end_esp_index, int best_end_esp_num)

Update HSP data after reevaluation with ambiguities.

Boolean Blast_HSPTestIdentityAndLength(EBlastProgramType program_number, BlastHSP *hsp, const Uint1 *query, const Uint1 *subject, const BlastScoringOptions *score_options, const BlastHitSavingOptions *hit_options)

Calculates number of identities and alignment lengths of an HSP via Blast_HSPGetNumIdentities and det...

Int4 Blast_HSPListSubjectBestHit(EBlastProgramType program, const BlastHSPSubjectBestHitOptions *subject_besthit_opts, const BlastQueryInfo *query_info, BlastHSPList *hsp_list)

static int s_SortHSPListByOid(const void *x, const void *y)

callback used to sort HSP lists in order of increasing OID

Int2 Blast_HSPResultsReverseOrder(BlastHSPResults *results)

Reverse order of HSP lists in each hit list in the BLAST results.

BlastHSPResults * Blast_HSPResultsFromHSPStream(BlastHSPStream *hsp_stream, size_t num_queries, SBlastHitsParameters *bhp)

Move all of the hits within an HSPStream into a BlastHSPResults structure.

static Int4 s_HSPEndDiag(const BlastHSP *hsp)

Retrieve the ending diagonal of an HSP.

Boolean Blast_HSPList_IsEmpty(const BlastHSPList *hsp_list)

Returns true if the BlastHSPList contains no HSPs.

BlastHitList * Blast_HitListNew(Int4 hitlist_size)

Allocate memory for a hit list of a given size.

Int2 Blast_HSPGetPartialSubjectTranslation(BLAST_SequenceBlk *subject_blk, BlastHSP *hsp, Boolean is_ooframe, const Uint1 *gen_code_string, Uint1 **translation_buffer_ptr, Uint1 **subject_ptr, Int4 *subject_length_ptr, Int4 *start_shift_ptr)

Performs the translation and coordinates adjustment, if only part of the subject sequence is translat...

Int2 Blast_HitListSortByEvalue(BlastHitList *hit_list)

Sort BlastHitLIst bon evalue.

Int4 Blast_HSPListPurgeHSPsWithCommonEndpoints(EBlastProgramType program, BlastHSPList *hsp_list, Boolean purge)

Check for an overlap of two different alignments and remove redundant HSPs.

Int2 Blast_HSPResultsInsertHSPList(BlastHSPResults *results, BlastHSPList *hsp_list, Int4 hitlist_size)

Blast_HSPResultsInsertHSPList Insert an HSP list to the appropriate place in the results structure.

void Blast_HSPGetAdjustedOffsets(EBlastProgramType program, BlastHSP *hsp, Int4 query_length, Int4 subject_length, Int4 *q_start, Int4 *q_end, Int4 *s_start, Int4 *s_end)

Adjust HSP endpoint offsets according to strand/frame; return values in 1-offset coordinates instead ...

void Blast_HSPCalcLengthAndGaps(const BlastHSP *hsp, Int4 *length_out, Int4 *gaps_out, Int4 *gap_opens_out)

Calculate length of an HSP as length in query plus length of gaps in query.

BlastHSPList * Blast_HSPListNew(Int4 hsp_max)

Creates HSP list structure with a default size HSP array.

static int s_EvalueComp(double evalue1, double evalue2)

Compares 2 evalues, consider them equal if both are close enough to zero.

static void s_BlastHSPListInsertHSPInHeap(BlastHSPList *hsp_list, BlastHSP **hsp)

Given a BlastHSPList* with a heapified HSP array, check whether the new HSP is better than the worst ...

static void s_CutOffGapEditScript(BlastHSP *hsp, Int4 q_cut, Int4 s_cut, Boolean cut_begin)

Int2 Blast_HSPGetNumIdentities(const Uint1 *query, const Uint1 *subject, BlastHSP *hsp, const BlastScoringOptions *score_options, Int4 *align_length_ptr)

Calculate number of identities in an HSP and set the BlastHSP::num_ident field (unconditionally)

Int2 Blast_HSPListPurgeNullHSPs(BlastHSPList *hsp_list)

Cleans out the NULLed out HSP's from the HSP array that is part of the BlastHSPList.

BlastHSPMappingInfo * BlastHSPMappingInfoNew(void)

Allocate memory for an HSP's additional data structure.

BlastHSPList * BlastHSPListDup(const BlastHSPList *hsp_list)

Returns a duplicate (deep copy) of the given hsp list.

Boolean Blast_HSPTest(BlastHSP *hsp, const BlastHitSavingOptions *hit_options, Int4 align_length)

Determines whether this HSP should be kept or deleted.

struct SHspWrap SHspWrap

Auxiliary structure for sorting HSPs.

BlastHSPResults * Blast_HSPResultsNew(Int4 num_queries)

Initialize the results structure.

BlastHSPMappingInfo * BlastHSPMappingInfoFree(BlastHSPMappingInfo *info)

Deallocate memory for an HSP's additional data structure.

Boolean Blast_HSPReevaluateWithAmbiguitiesGapped(BlastHSP *hsp, const Uint1 *q, const Int4 qlen, const Uint1 *s, const Int4 slen, const BlastHitSavingParameters *hit_params, const BlastScoringParameters *score_params, const BlastScoreBlk *sbp)

Reevaluate the HSP's score and percent identity after taking into account the ambiguity information.

BlastHSP * Blast_HSPClone(const BlastHSP *hsp)

Make a deep copy of an HSP.

Int2 Blast_HitListPurgeNullHSPLists(BlastHitList *hit_list)

Purges a BlastHitList of NULL HSP lists.

Int2 Blast_HSPListGetEvalues(EBlastProgramType program_number, const BlastQueryInfo *query_info, Int4 subject_length, BlastHSPList *hsp_list, Boolean gapped_calculation, Boolean RPS_prelim, const BlastScoreBlk *sbp, double gap_decay_rate, double scaling_factor)

Calculate the expected values for all HSPs in a hit list, without using the sum statistics.

static Boolean s_HSPTest(const BlastHSP *hsp, const BlastHitSavingOptions *hit_options, Int4 align_length)

Int2 Blast_HSPListReevaluateUngapped(EBlastProgramType program, BlastHSPList *hsp_list, BLAST_SequenceBlk *query_blk, BLAST_SequenceBlk *subject_blk, const BlastInitialWordParameters *word_params, const BlastHitSavingParameters *hit_params, const BlastQueryInfo *query_info, BlastScoreBlk *sbp, const BlastScoringParameters *score_params, const BlastSeqSrc *seq_src, const Uint1 *gen_code_string)

Reevaluate all ungapped HSPs in an HSP list.

Boolean Blast_HSPQueryCoverageTest(BlastHSP *hsp, double min_query_coverage_pct, Int4 query_length)

Calculate query coverage percentage of an hsp.

int ScoreCompareHSPs(const void *h1, const void *h2)

Comparison callback function for sorting HSPs, first by score in descending order,...

Int2 Blast_TrimHSPListByMaxHsps(BlastHSPList *hsp_list, const BlastHitSavingOptions *hit_options)

Int2 Blast_HSPListSaveHSP(BlastHSPList *hsp_list, BlastHSP *new_hsp)

Saves HSP information into a BlastHSPList structure.

SBlastHitsParameters * SBlastHitsParametersFree(SBlastHitsParameters *param)

Deallocated SBlastHitsParameters.

static Boolean s_BlastMergeTwoHSPs(BlastHSP *hsp1, BlastHSP *hsp2, Boolean allow_gap)

Given two hits, check if the hits can be merged and do the merge if so.

static int s_SortHspWrapRawScore(const void *x, const void *y)

callback used to sort a list of encapsulated HSP structures in order of decreasing raw score -RMH-

void Blast_HSPListAdjustOddBlastnScores(BlastHSPList *hsp_list, Boolean gapped_calculation, const BlastScoreBlk *sbp)

For nucleotide BLAST, if the match reward score is equal to 2, random alignments are dominated by run...

static void s_Heapify(char *base0, char *base, char *lim, char *last, size_t width, int(*compar)(const void *, const void *))

This is a copy of a static function from ncbimisc.c.

static int s_QueryEndCompareHSPs(const void *v1, const void *v2)

Callback for sorting HSPs by ending offset in query.

Int2 Blast_HSPListReapByQueryCoverage(BlastHSPList *hsp_list, const BlastHitSavingOptions *hit_options, const BlastQueryInfo *query_info, EBlastProgramType program_number)

Discard the HSPs below the min query coverage pct from the HSP list.

BlastHSP * Blast_HSPFree(BlastHSP *hsp)

Deallocate memory for an HSP structure.

Int2 Blast_HSPResultsApplyMasklevel(BlastHSPResults *results, const BlastQueryInfo *query_info, Int4 masklevel, Int4 query_length)

Apply Cross_match like masklevel to HSP list.

Boolean Blast_HSPListIsSortedByScore(const BlastHSPList *hsp_list)

Check if HSP list is sorted by score.

static void s_BlastHSPListsCombineByScore(BlastHSPList *hsp_list, BlastHSPList *combined_hsp_list, Int4 new_hspcnt)

Combine two HSP lists, without altering the individual HSPs, and without reallocating the HSP array.

BlastHSPResults * Blast_HSPResultsFromHSPStreamWithLimitEx(BlastHSPStream *hsp_stream, Uint4 num_queries, SBlastHitsParameters *hit_param, Uint4 max_num_hsps, Boolean *removed_hsps)

As Blast_HSPResultsFromHSPStreamWithLimit, except accept and return array of Boolen flags specifying ...

const Uint1 * Blast_HSPGetTargetTranslation(SBlastTargetTranslation *target_t, const BlastHSP *hsp, Int4 *translated_length)

Returns a buffer with a protein translated from nucleotide.

static int s_QueryOffsetCompareHSPs(const void *v1, const void *v2)

Callback for sorting HSPs by starting offset in query.

static Boolean s_UpdateReevaluatedHSPUngapped(BlastHSP *hsp, Int4 cutoff_score, Int4 score, const Uint1 *query_start, const Uint1 *subject_start, const Uint1 *best_q_start, const Uint1 *best_q_end, const Uint1 *best_s_start, const Uint1 *best_s_end)

Update HSP data after reevaluation with ambiguities for an ungapped search.

static double s_BlastGetBestEvalue(const BlastHSPList *hsp_list)

Gets the best (lowest) evalue from the BlastHSPList.

struct BlastHSPwOid BlastHSPwOid

Int4 GetPrelimHitlistSize(Int4 hitlist_size, Int4 compositionBasedStats, Boolean gapped_calculation)

static int s_EvalueCompareHSPLists(const void *v1, const void *v2)

Callback for sorting hsp lists by their best evalue/score; Evalues are compared with the condition th...

#define OVERLAP_DIAG_CLOSE

Maximal diagonal distance between HSP starting offsets, within which HSPs from search of different ch...

static Int2 s_Blast_HitListGrowHSPListArray(BlastHitList *hit_list)

Given a BlastHitList pointer this function makes the hsplist_array larger, up to a maximum size.

BlastHSPResults ** PHIBlast_HSPResultsSplit(const BlastHSPResults *results, const SPHIQueryInfo *pattern_info)

Splits the BlastHSPResults structure for a PHI BLAST search into an array of BlastHSPResults structur...

void Blast_HSPAdjustSubjectOffset(BlastHSP *hsp, Int4 start_shift)

Adjusts offsets if partial sequence was used for extension.

BlastHSPList * Blast_HSPListFree(BlastHSPList *hsp_list)

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

double Blast_HSPGetQueryCoverage(const BlastHSP *hsp, Int4 query_length)

Calculate query coverage percentage of an hsp.

Boolean Blast_HSPReevaluateWithAmbiguitiesUngapped(BlastHSP *hsp, const Uint1 *query_start, const Uint1 *subject_start, const BlastInitialWordParameters *word_params, BlastScoreBlk *sbp, Boolean translated)

Reevaluate the HSP's score and percent identity after taking into account the ambiguity information.

static int s_EvalueCompareHSPListsRev(const void *v1, const void *v2)

Callback for sorting hsp lists by their best e-value/score, in reverse order - from higher e-value to...

static void s_HSPPHIGetEvalue(BlastHSP *hsp, BlastScoreBlk *sbp, const BlastQueryInfo *query_info, const SPHIPatternSearchBlk *pattern_blk)

Calculate e-value for an HSP found by PHI BLAST.

static BlastHSP * s_BlastHSPCopy(const BlastHSP *hsp)

Copies all contents of a BlastHSP structure.

Int2 SBlastHitsParametersNew(const BlastHitSavingOptions *hit_options, const BlastExtensionOptions *ext_options, const BlastScoringOptions *scoring_options, SBlastHitsParameters **retval)

Sets up small structures used by blast_hit.c for saving HSPs.

static Int4 s_HSPStartDiag(const BlastHSP *hsp)

Retrieve the starting diagonal of an HSP.

Int4 PhiBlastGetEffectiveNumberOfPatterns(const BlastQueryInfo *query_info)

Count the number of occurrences of pattern in sequence, which do not overlap by more than half the pa...

static Boolean s_BlastCheckBestEvalue(const BlastHSPList *hsp_list)

Verifies that the best_evalue field on the BlastHSPList is correct.

static Boolean s_TrimResultsByTotalHSPLimit(BlastHSPResults *results, Uint4 total_hsp_limit)

Removes extra results if a limit is imposed on the total number of HSPs returned.

static void s_BlastSegGetTranslatedOffsets(const BlastSeg *segment, Int4 seq_length, Int4 *start, Int4 *end)

Adjust start and end of an HSP in a translated sequence segment.

void Blast_HSPListPHIGetBitScores(BlastHSPList *hsp_list, BlastScoreBlk *sbp)

Calculate bit scores from raw scores in an HSP list for a PHI BLAST search.

void Blast_HSPListSwap(BlastHSPList *list1, BlastHSPList *list2)

Swaps the two HSP lists via structure assignment.

void Blast_HSPListSortByScore(BlastHSPList *hsp_list)

Sort the HSPs in an HSP list by score.

Int2 Blast_HSPListReapByEvalue(BlastHSPList *hsp_list, const BlastHitSavingOptions *hit_options)

Discard the HSPs above the e-value threshold from the HSP list.

Int2 Blast_HSPListsMerge(BlastHSPList **hsp_list_ptr, BlastHSPList **combined_hsp_list_ptr, Int4 hsp_num_max, Int4 *split_offsets, Int4 contexts_per_query, Int4 chunk_overlap_size, Boolean allow_gap, Boolean short_reads)

Merge an HSP list from a chunk of the subject sequence into a previously computed HSP list.

SBlastHitsParameters * SBlastHitsParametersDup(const SBlastHitsParameters *hit_params)

Make a deep copy of the SBlastHitsParameters structure passed in.

Int2 Blast_HSPListGetBitScores(BlastHSPList *hsp_list, Boolean gapped_calculation, const BlastScoreBlk *sbp)

Calculate bit scores from raw scores in an HSP list.

static int s_CompareScoreHSPwOid(const void *v1, const void *v2)

Int2 Blast_HitListUpdate(BlastHitList *hit_list, BlastHSPList *hsp_list)

Insert a new HSP list into the hit list.

static Int2 s_Blast_HSPGetNumIdentitiesAndPositives(const Uint1 *query, const Uint1 *subject, const BlastHSP *hsp, Int4 *num_ident_ptr, Int4 *align_length_ptr, const BlastScoreBlk *sbp, Int4 *num_pos_ptr)

Calculate number of identities in a regular HSP.

void Blast_HSPListAdjustOffsets(BlastHSPList *hsp_list, Int4 offset)

Adjust subject offsets in an HSP list if only part of the subject sequence was searched.

Structures and API used for saving BLAST hits.

Utilities for dealing with BLAST HSPs in the core of BLAST.

#define CONTAINED_IN_HSP(a, b, c, d, e, f)

TRUE if c is between a and b; f between d and e.

Declaration of ADT to save and retrieve lists of HSPs in the BLAST engine.

const int kBlastHSPStream_Eof

Return value when the end of the stream is reached (applicable to read method only)

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

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

Int4 BlastIntervalTreeMasksHSP(const BlastIntervalTree *tree, const BlastHSP *hsp, const BlastQueryInfo *query_info, Int4 subtree_index, Int4 masklevel)

void Blast_IntervalTreeReset(BlastIntervalTree *tree)

Empty an interval tree structure but do not free it.

BlastIntervalTree * Blast_IntervalTreeInit(Int4 q_start, Int4 q_end, Int4 s_start, Int4 s_end)

Initialize an interval tree structure.

Int2 BlastIntervalTreeAddHSP(BlastHSP *hsp, BlastIntervalTree *tree, const BlastQueryInfo *query_info, EITreeIndexMethod index_method)

Add an HSP to an existing interval tree.

BlastIntervalTree * Blast_IntervalTreeFree(BlastIntervalTree *tree)

Deallocate an interval tree structure.

Interface for an interval tree, used for fast HSP containment tests.

@ eQueryOnlyStrandIndifferent

Index by query offset only.

#define BLASTERR_MEMORY

System error: out of memory condition.

Boolean Blast_ProgramIsPhiBlast(EBlastProgramType p)

Returns true if program is PHI-BLAST (i.e.

Boolean Blast_QueryIsTranslated(EBlastProgramType p)

Returns true if the query is translated.

Boolean Blast_SubjectIsNucleotide(EBlastProgramType p)

Returns true if the subject is nucleotide.

Boolean Blast_ProgramIsRpsBlast(EBlastProgramType p)

Returns true if program is RPS-BLAST (i.e.

EBlastProgramType

Defines the engine's notion of the different applications of the BLAST algorithm.

Boolean Blast_SubjectIsTranslated(EBlastProgramType p)

Returns true if the subject is translated.

void BlastSeqSrcReleaseSequence(const BlastSeqSrc *seq_src, BlastSeqSrcGetSeqArg *getseq_arg)

Deallocate individual sequence.

#define BLAST_SEQSRC_EXCLUDED

Sequence excluded due to filtering.

Int2 BlastSeqSrcGetSequence(const BlastSeqSrc *seq_src, BlastSeqSrcGetSeqArg *getseq_arg)

Retrieve an individual sequence.

double BLAST_GapDecayDivisor(double decayrate, unsigned nsegs)

Compute a divisor used to weight the evalue of a collection of "nsegs" distinct alignments.

double BLAST_SpougeStoE(Int4 S, Blast_KarlinBlk *kbp, Blast_GumbelBlk *gbp, Int4 qlen, Int4 slen)

Calculates the Expect value based upon the Spouge's FSC method.

double BLAST_KarlinStoE_simple(Int4 S, Blast_KarlinBlk *kbp, Int8 searchsp)

Calculates the Expect value based upon the search space and some Karlin-Altschul parameters.

Various auxiliary BLAST utility functions.

Int4 BLAST_FrameToContext(Int2 frame, EBlastProgramType program)

Convert translation frame or strand into a context number suitable for indexing into the BlastQueryIn...

#define FENCE_SENTRY

This sentry value is used as a 'fence' around the valid portions of partially decoded sequences.

int Blast_GetPartialTranslation(const Uint1 *nucl_seq, Int4 nucl_length, Int2 frame, const Uint1 *genetic_code, Uint1 **translation_buffer_ptr, Int4 *protein_length, Uint1 **mixed_seq_ptr)

Get one frame translation - needed when only parts of subject sequences are translated.

Int2 BlastTargetTranslationNew(BLAST_SequenceBlk *subject_blk, const Uint1 *gen_code_string, EBlastProgramType program_number, Boolean is_ooframe, SBlastTargetTranslation **target)

Sets up structure for target translation.

SBlastTargetTranslation * BlastTargetTranslationFree(SBlastTargetTranslation *target_t)

Free SBlastTargetTranslation.

Int4 BLAST_GetTranslation(const Uint1 *query_seq, const Uint1 *query_seq_rev, Int4 nt_length, Int2 frame, Uint1 *buffer, const Uint1 *genetic_code)

GetTranslation to get the translation of the nucl.

#define MAX_FULL_TRANSLATION

Maximal unpacked subject sequence length for which full translation is performed up front.

Int2 GetReverseNuclSequence(const Uint1 *sequence, Int4 length, Uint1 **rev_sequence_ptr)

Reverse a nucleotide sequence in the blastna encoding, adding sentinel bytes on both ends.

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

GapEditScript * GapEditScriptDup(const GapEditScript *old)

Duplicates the edit script structure.

@ eGapAlignDel2

Frame shift deletion of two nucleotides.

@ eGapAlignIns2

Frame shift insertion of two nucleotides.

@ eGapAlignIns1

Frame shift insertion of one nucleotide.

@ eGapAlignIns

Insertion: a gap in subject.

@ eGapAlignDel1

Frame shift deletion of one nucleotide.

@ eGapAlignSub

Substitution.

@ eGapAlignDel

Deletion: a gap in query.

GapEditScript * GapEditScriptNew(Int4 size)

Initialize the edit script structure.

Int2 GapEditScriptPartialCopy(GapEditScript *new_esp, int offset, const GapEditScript *old_esp, int start, int stop)

Copies the portion of the GapEditScript specified by start and stop to a new one the new one should a...

GapEditScript * GapEditScriptDelete(GapEditScript *esp)

Free edit script structure.

@ eBlastEncodingNcbi4na

NCBI4na.

@ eBlastEncodingNucleotide

Special encoding for preliminary stage of BLAST: permutation of NCBI4na.

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

JumperEditsBlock * JumperEditsBlockFree(JumperEditsBlock *block)

SequenceOverhangs * SequenceOverhangsFree(SequenceOverhangs *overhangs)

JumperEditsBlock * JumperEditsBlockDup(const JumperEditsBlock *block)

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

Prototypes for portable math library (ported from C Toolkit)

#define NCBIMATH_LN2

Natural log(2)

#define MIN(a, b)

returns smaller of a and b.

#define INT4_MAX

largest nubmer represented by signed int

void * BlastMemDup(const void *orig, size_t size)

Copies memory using memcpy and malloc.

Uint1 Boolean

bool replacment for C

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

#define ABS(a)

returns absolute value of a (|a|)

#define ASSERT

macro for assert.

#define MAX(a, b)

returns larger of a and b.

double lambda(size_t dimMatrix_, const Int4 *const *scoreMatrix_, const double *q_)

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

static int pattern_info(int what, void *where, BOOL unsetok)

static const sljit_gpr r1

static const sljit_gpr r2

Structure to hold a sequence.

Uint1 * sequence_start

Start of sequence, usually one byte before sequence as that byte is a NULL sentinel byte.

Int4 oid

The ordinal id of the current sequence.

Int4 length

Length of sequence.

Uint1 * sequence_nomask

Start of query sequence without masking.

Uint1 * sequence

Sequence used for search (could be translation).

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.

Int4 length_adjustment

Length adjustment for boundary conditions.

Int8 eff_searchsp

Effective search space for this context.

Options used for gapped extension These include: a.

Int4 compositionBasedStats

mode of compositional adjustment to use; if zero then compositional adjustment is not used

Int4 cutoff_score

Raw cutoff score corresponding to the e-value provided by the user if no sum stats,...

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

Boolean do_not_reallocate

Is reallocation of the hsp_array allowed?

Int4 oid

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

Int4 hspcnt

Number of HSPs saved.

BlastHSP ** hsp_array

Array of pointers to individual HSPs.

Int4 hsp_max

The maximal number of HSPs allowed to be saved.

double best_evalue

Smallest e-value for HSPs in this list.

Int4 allocated

The allocated size of the hsp_array.

Int4 query_index

Index of the query which this HSPList corresponds to.

Mapping information for an HSP.

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.

The structure to contain all BLAST results, for multiple queries.

BlastHitList ** hitlist_array

Array of results for individual query sequences.

Int4 num_queries

Number of query sequences.

Default implementation of BlastHSPStream.

unsigned int max_range_diff

Structure holding all information about an HSP.

SPHIHspInfo * pat_info

In PHI BLAST, information about this pattern match.

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.

double bit_score

Bit score, calculated from score.

Int4 num

How many HSP's are linked together for sum statistics evaluation? If unset (0), this HSP is not part ...

BlastSeg subject

Subject sequence info.

GapEditScript * gap_info

ALL gapped alignment is here.

Int2 comp_adjustment_method

which mode of composition adjustment was used; relevant only for blastp and tblastn

Int4 score

This HSP's raw score.

BlastHSPMappingInfo * map_info

The structure to contain all BLAST results for one query sequence.

double worst_evalue

Highest of the best e-values among the HSP lists.

Int4 hsplist_max

Maximal allowed size of the HSP lists array.

BlastHSPList ** hsplist_array

Array of HSP lists for individual database hits.

Int4 hsplist_count

Filled size of the HSP lists array.

Int4 low_score

The lowest of the best scores among the HSP lists.

Int4 hsplist_current

Number of allocated HSP list arrays.

Boolean heapified

Is this hit list already heapified?

Options used when evaluating and saving hits These include: a.

Int4 max_hsps_per_subject

Queries are paired reads, for mapping.

double expect_value

The expect value cut-off threshold for an HSP, or a combined hit if sum statistics is used.

Int4 cutoff_score

The (raw) score cut-off threshold.

Int4 hsp_num_max

Maximal number of HSPs to save for one database sequence.

Int4 hitlist_size

Maximal number of database sequences to return results for.

double query_cov_hsp_perc

Min query coverage hsp percentage.

double percent_identity

The percent identity cut-off threshold.

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

BlastGappedCutoffs * cutoffs

per-context gapped cutoff information

BlastHitSavingOptions * options

The original (unparsed) options.

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

BlastUngappedCutoffs * cutoffs

cutoff values (one per context)

Main structure describing an interval tree.

The query related information.

BlastContextInfo * contexts

Information per context.

struct SPHIQueryInfo * pattern_info

Counts of PHI BLAST pattern occurrences, used in PHI BLAST only.

Structure used for scoring calculations.

Boolean protein_alphabet

TRUE if alphabet_code is for a protein alphabet (e.g., ncbistdaa etc.), FALSE for nt.

Blast_KarlinBlk ** kbp

Karlin-Altschul parameters.

Blast_KarlinBlk ** kbp_gap

K-A parameters for gapped alignments.

Boolean round_down

Score must be rounded down to nearest even score if odd.

Int4 number_of_contexts

Used by sfp and kbp, how large are these.

SBlastScoreMatrix * matrix

scoring matrix data

Blast_GumbelBlk * gbp

Gumbel parameters for FSC.

Scoring options block Used to produce the BlastScoreBlk structure This structure may be needed for lo...

EBlastProgramType program_number

indicates blastn, blastp, etc.

Boolean gapped_calculation

gap-free search if FALSE

Boolean is_ooframe

Should out-of-frame gapping be used in a translated search?

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)

BlastScoringOptions * options

User-provided values for these params.

Int2 reward

Reward for a match.

One sequence segment within an HSP.

Int4 gapped_start

Where the gapped extension started.

Int2 frame

Translation frame.

Int4 offset

Start of hsp.

Structure used as the second argument to functions satisfying the GetSeqBlkFnPtr signature,...

Int4 oid

Oid in BLAST database, index in an array of sequences, etc [in].

EBlastEncoding encoding

Encoding of sequence, i.e.

Boolean check_oid_exclusion

Check whether an OID is excluded due to overlapping filtering.

BLAST_SequenceBlk * seq

Sequence to return, if NULL, it should allocated by GetSeqBlkFnPtr (using BlastSeqBlkNew or BlastSetU...

Complete type definition of Blast Sequence Source ADT.

Int4 cutoff_score

Cutoff score for saving ungapped hits.

Structure to hold the Karlin-Altschul parameters.

double paramC

for use in seed.

double Lambda

Lambda value used in statistics.

double logK

natural log of K value used in statistics

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.

Keeps prelim_hitlist_size and HitSavingOptions together, mostly for use by hspstream.

Int4 prelim_hitlist_size

number of hits saved during preliminary part of search.

int ** data

actual scoring matrix data, stored in row-major form

Information about target translations.

EBlastProgramType program_number

Program being run.

Int4 * range

start and stop of translated sequences.

const Uint1 * gen_code_string

Genetic code string for translation.

BLAST_SequenceBlk * subject_blk

target sequence being translated.

Uint1 ** translations

two dimensional array for translations.

Boolean partial

specifies that nucleotide sequence is too long to translated.

Auxiliary structure for sorting HSPs.

BlastHSP * hsp

HSP described by this structure.

BlastHSPList * hsplist

The HSPList to which this HSP belongs.

In PHI BLAST: information about pattern match in a given HSP.

Int4 index

Index of query pattern occurrence for this HSP.

Int4 offset

Starting offset of this pattern occurrence.

Structure containing all auxiliary information needed in a pattern search.

Int4 num_patterns_db

Number of patterns actually found during the database search.

In PHI BLAST, structure containing information about all pattern occurrences in query.

Int4 num_patterns

Number of pattern occurrences in query.

SPHIPatternInfo * occurrences

Array of pattern occurrence information structures.

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.

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