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

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

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

(q_off == q_pos)

;

(index == q_pos)

;

(index == -1 || index >= 0)

;

index = overflow[src_off++];

(index == q_pos)

;

index = overflow[src_off++];

index &= (

->mask);

num_hits =

->thick_backbone[index].num_used;

->thick_backbone[index].payload.entries :

->overflow +

->thick_backbone[index].payload.overflow_cursor;

(

=0;

<num_hits; ++

) {

(lookup_pos[

] == q_pos)

;

*subject0, *sf, *q_beg, *q_end, *s, *start;

remainder, base;

q_avail, s_avail;

base = 3 - (s_off % 4);

q_avail =

->length - q_off;

s_avail =

->length - s_off;

q = q_beg = q_end =

->sequence + q_off;

((s > start) || (s == start && base < remainder)) {

}

(sum < X) {

ungapped_data->

= s_off - (q_off - ungapped_data->

);

(q_avail < s_avail) {

q =

->sequence + q_off;

(s < sf || (s == sf && base > remainder)) {

X_current = (-score > X) ? -score : X;

}

(sum < X_current)

ungapped_data->

= (

)(q_end - q_beg);

ungapped_data->

= score;

* score_table,

reduced_cutoff)

q_ext = q_off +

;

s_ext = s_off +

;

(

= 0;

<

; s--, q -= 4,

++) {

s_byte = s[-1];

q_byte = (q[-4] << 6) | (q[-3] << 4) | (q[-2] << 2) | q[-1];

sum += score_table[q_byte ^ s_byte];

ungapped_data->

= (

)(new_q - q_start);

ungapped_data->

= s_ext - (q_ext - ungapped_data->

);

(

= 0;

<

; s++, q += 4,

++) {

q_byte = (q[0] << 6) | (q[1] << 4) | (q[2] << 2) | q[3];

sum += score_table[q_byte ^ s_byte];

(score >= reduced_cutoff) {

s_off, X, ungapped_data);

ungapped_data->

= score;

ungapped_data->

+ 1) );

(

->chain[index].diag == diag) {

*level =

->chain[index].level;

*hit_len =

->chain[index].hit_len;

*hit_saved =

->chain[index].hit_saved;

index =

->chain[index].next;

(

->chain[index].diag == diag) {

->chain[index].level = level;

->chain[index].hit_len =

;

->chain[index].hit_saved = hit_saved;

->chain[index].diag = diag;

->chain[index].level = level;

->chain[index].hit_len =

;

->chain[index].hit_saved = hit_saved;

index =

->chain[index].next;

->capacity *= 2;

cell->

= level;

lut_word_length,

index = (s[0] << 24 | s[1] << 16 | s[2] << 8) >> shift;

index = (s[0] << 24 | s[1] << 16 ) >> shift;

index = (s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3]) >> shift;

(lookup_wrap, index, q_pos));

lut_word_length,

ext_to, ext_max;

q_end = *q_off + word_length;

s_end = *s_off + word_length;

(word_length == lut_word_length)

1;

s_end - lut_word_length,

q_end - lut_word_length))

0;

(;

; ++(*s_off), ++(*q_off)) {

*s_off, lut_word_length, *q_off))

;

ext_to = word_length - (q_end - (*q_off));

ext_max =

(q_range - q_end, s_range - s_end);

(ext_to || locations) {

(ext_to > ext_max)

0;

(s_pos = s_end - lut_word_length,

q_pos = q_end - lut_word_length;

s_pos -= lut_word_length,

q_pos -= lut_word_length) {

s_pos, lut_word_length, q_pos))

0;

(*extended) = ext_to;

(!check_double)

1;

ext_to += word_length;

ext_max =

(ext_max, ext_to);

(s_pos = s_end, q_pos = q_end;

*extended + lut_word_length <= ext_max;

s_pos += lut_word_length,

q_pos += lut_word_length,

(*extended) += lut_word_length) {

lut_word_length, q_pos))

;

s_pos -= (lut_word_length - 1);

q_pos -= (lut_word_length - 1);

(*extended < ext_max) {

lut_word_length, q_pos))

1;

((ext_max == ext_to) ? 2 : 1);

word_length,

lut_word_length,

diag, real_diag;

s_end, s_off_pos, s_end_pos;

last_hit, hit_saved;

real_diag = diag & diag_table->

;

last_hit = hit_level_array[real_diag].

;

hit_saved = hit_level_array[real_diag].

;

s_end = s_off + word_length;

s_off_pos = s_off + diag_table->

;

s_end_pos = s_end + diag_table->

;

(s_off_pos < last_hit)

0;

(two_hits && (hit_saved || s_end_pos > last_hit +

)) {

query_mask, query_info, s_range,

word_length, lut_word_length, lut,

, &extended);

(!word_type)

0;

s_end_pos += extended;

(word_type == 1) {

s_b = s_end_pos - 2 * word_length;

(Delta < 0) Delta = 0;

&& off_s_end -

>= s_a

&& off_s_end - off_s_l <= s_b) {

off_s_end = hit_level_array[off_diag].

;

&& off_s_end - off_s_l +

<= s_b) {

}

(check_masks) {

query_mask, query_info, s_range,

word_length, lut_word_length, lut,

, &extended))

0;

s_end_pos += extended;

ungapped_data = &dummy_ungapped_data;

s_off, -(cutoffs->

), ungapped_data);

*final_data = *ungapped_data;

ungapped_data =

;

hit_level_array[real_diag].

= s_end_pos;

hit_level_array[real_diag].

= hit_ready;

diag_table->

[real_diag] = (hit_ready) ? 0 : s_end_pos - s_off_pos;

word_length,

lut_word_length,

s_end, s_off_pos, s_end_pos, s_l;

last_hit, hit_saved = 0;

diag = s_off - q_off;

s_end = s_off + word_length;

s_off_pos = s_off + hash_table->

;

s_end_pos = s_end + hash_table->

;

(!rc) last_hit = 0;

(s_off_pos < last_hit)

0;

(two_hits && (hit_saved || s_end_pos > last_hit +

)) {

query_mask, query_info, s_range,

word_length, lut_word_length, lut,

, &extended);

(!word_type)

0;

s_end_pos += extended;

(word_type == 1) {

s_b = s_end_pos - 2 * word_length;

(Delta < 0) Delta = 0;

off_hit_saved = 0;

&off_s_end, &off_s_l, &off_hit_saved);

&& off_s_end -

>= s_a

&& off_s_end - off_s_l <= s_b) {

&off_s_end, &off_s_l, &off_hit_saved);

&& off_s_end - off_s_l +

<= s_b) {

}

(check_masks) {

query_mask, query_info, s_range,

word_length, lut_word_length, lut,

, &extended))

0;

s_end_pos += extended;

ungapped_data = &dummy_ungapped_data;

s_off, -(cutoffs->

), ungapped_data);

*final_data = *ungapped_data;

ungapped_data =

;

(hit_ready) ? 0 : s_end_pos - s_off_pos,

hits_extended = 0;

check_masks = !lut->

;

(; index < num_hits; ++index) {

query_info, s_range,

word_length, word_length,

word_params, matrix,

(; index < num_hits; ++index) {

query_info, s_range,

word_length, word_length,

word_params, matrix,

hits_extended;

hits_extended = 0;

word_length, lut_word_length, ext_to;

check_masks = !lut->

;

ext_to = word_length - lut_word_length;

(; index < num_hits; ++index) {

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;

query_info, s_range,

word_length, lut_word_length,

word_params, matrix,

query_info, s_range,

word_length, lut_word_length,

word_params, matrix,

hits_extended;

hits_extended = 0;

word_length, lut_word_length, ext_to;

check_masks = !lut->

;

ext_to = word_length - lut_word_length;

(; index < num_hits; ++index) {

ext_max =

(ext_to, s_offset);

(; ext_left < ext_max; s--, q -= 4, ++ext_left) {

((

& 3) != q[-1] || ++ext_left == ext_max)

(((

>> 2) & 3) != q[-2] || ++ext_left == ext_max)

(((

>> 4) & 3) != q[-3] || ++ext_left == ext_max)

((

>> 6) != q[-4])

(ext_left < ext_to) {

ext_max = ext_to -ext_left;

(s_offset + lut_word_length + ext_max > s_range)

q =

->sequence + q_offset + lut_word_length;

(; ext_right < ext_max; s++, q += 4, ++ext_right) {

((

>> 6) != q[0] || ++ext_right == ext_max)

(((

>> 4) & 3) != q[1] || ++ext_right == ext_max)

(((

>> 2) & 3) != q[2] || ++ext_right == ext_max)

((

& 3) != q[3])

(ext_left + ext_right < ext_to)

q_offset -= ext_left;

s_offset -= ext_left;

query_info, s_range,

word_length, lut_word_length,

word_params, matrix,

query_info, s_range,

word_length, lut_word_length,

word_params, matrix,

hits_extended;

4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,

4, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

hits_extended = 0;

ext_to = word_length - lut_word_length;

(; index < num_hits; ++index) {

( (s_offset > 0) && (q_offset > 0) ) {

q_byte = q[q_offset - 4];

ext_left =

(

(ext_left, ext_to), q_offset - q_start);

((ext_left < ext_to) && ((q_offset + lut_word_length) <

->length)) {

q_byte = q[q_offset + lut_word_length];

ext_right =

(

(ext_right, s_range - (s_offset + lut_word_length)),

q_range - (q_offset + lut_word_length));

(ext_left + ext_right < ext_to)

q_offset -= ext_left;

s_offset -= ext_left;

query_info, s_range,

word_length, lut_word_length,

word_params, matrix,

query_info, s_range,

word_length, lut_word_length,

word_params, matrix,

hits_extended;

hits_extended = 0;

(; index < num_hits; ++index) {

ext_max =

(

(word_length - lut_word_length, s_offset), q_offset - q_start);

(ext_left < ext_max) {

q_byte = q[q_off - 4];

ext_left =

(ext_left, ext_max);

ext_max =

(

(word_length - ext_left, s_range - s_off), q_range - q_off);

(ext_right < ext_max) {

q_byte = q[q_off];

ext_right =

(ext_right, ext_max);

(ext_left + ext_right < word_length)

q_offset -= ext_left;

s_offset -= ext_left;

query_info, s_range,

word_length, lut_word_length,

word_params, matrix,

query_info, s_range,

word_length, lut_word_length,

word_params, matrix,

hits_extended;

hitsfound, total_hits = 0;

hits_extended = 0;

lut_word_length;

word_length =

->word_length;

lut_word_length =

->lut_word_length;

word_length =

->template_length;

lut_word_length =

->template_length;

word_length =

->word_length;

lut_word_length =

->lut_word_length;

word_length =

->word_length;

lut_word_length =

->lut_word_length;

scan_range[2] =

->length - lut_word_length;

scan_range[1] =

->seq_ranges[0].left + word_length - lut_word_length;

scan_range[2] =

->seq_ranges[0].right - lut_word_length;

hitsfound = scansub(lookup_wrap,

, offset_pairs, max_hits, &scan_range[1]);

total_hits += hitsfound;

hits_extended += extend(offset_pairs, hitsfound, word_params,

query_info, ewp, init_hitlist, scan_range[2] + lut_word_length);

init_hitlist->

);

( check_oid( oid, &last_vol_idx ) ==

) {

,

, query_info, lookup_wrap, matrix,word_params,

ewp, offset_pairs, max_hits, init_hitlist, ungapped_stats );

hsp_end = hsp + init_hitlist->

;

( ; hsp < hsp_end; ++hsp ) {

diag =

( q_off, s_off );

q_off, s_off + word_size, s_off,

-(cutoffs->

), &dummy_ungapped_data,

*ungapped_data = dummy_ungapped_data;

( new_hsp != hsp ) *new_hsp = *hsp;

( new_hsp != hsp ) *new_hsp = *hsp;

(

= 1;

< num_arrays;

++) {

hitsfound, total_hits = 0;

hits_extended = 0;

lut_word_length;

(*hsp_list_ptr ==

) {

hsp_list = *hsp_list_ptr;

word_length =

->word_length;

lut_word_length =

->lut_word_length;

word_length =

->template_length;

lut_word_length =

->template_length;

word_length =

->word_length;

lut_word_length =

->lut_word_length;

word_length =

->word_length;

lut_word_length =

->lut_word_length;

word_length =

->word_length;

lut_word_length =

->lut_word_length;

scan_range[2] =

->length - lut_word_length;

scan_range[1] =

->seq_ranges[0].left + word_length - lut_word_length;

scan_range[2] =

->seq_ranges[0].right - lut_word_length;

(getenv(

)) {

hitsfound = scansub(lookup_wrap,

, offset_pairs, max_hits, &scan_range[1]);

(hitsfound >= 0) {

(

= 0;

< hitsfound;

++) {

diag = s_off - q_off;

(last_p != 0 && last_d == diag &&

s_off - last_p < lut_word_length + 1) {

(index < word_hits->num_arrays);

word_hits->

[index],

word_params, score_params,

scan_range[2] + lut_word_length,

word_hits->

[index] = 0;

total_hits += hitsfound;

word_params, score_params,

scan_range[2] + lut_word_length,

(!read_is_query) {

(word_hits->

[

] > 0) {

word_hits->

[

],

word_params, score_params,

scan_range[2] + lut_word_length,

word_hits->

[

] = 0;

( check_oid( oid, &last_vol_idx ) ==

) {

,

, query_info, lookup_wrap, word_params,

score_params, hit_params, offset_pairs, word_hits, max_hits,

gap_align, init_hitlist, hsp_list, ungapped_stats,

(*hsp_list ==

) {

( word_size > 0) {

hsp_end = hsp + init_hitlist->

;

( ; hsp < hsp_end; ++hsp ) {

diag =

( q_off, s_off );

* query_seq =

->sequence + query_start;

num_identical = 0;

right_ungapped_ext_len = 0;

q_off - query_start,

&right_ungapped_ext_len);

q_off - query_start, s_off,

#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.

void Blast_UngappedStatsUpdate(BlastUngappedStats *ungapped_stats, Int4 total_hits, Int4 extended_hits, Int4 saved_hits)

Fill data in the ungapped hits diagnostics structure.

Boolean BLAST_SaveInitialHit(BlastInitHitList *init_hitlist, Int4 q_off, Int4 s_off, BlastUngappedData *ungapped_data)

Save the initial hit data into the initial hit list structure.

void Blast_InitHitListSortByScore(BlastInitHitList *init_hitlist)

Sort array of initial HSPs by score.

Int2 Blast_ExtendWordExit(Blast_ExtendWord *ewp, Int4 subject_length)

Update the word extension structure after scanning of each subject sequence.

#define DIAGHASH_NUM_BUCKETS

Number of hash buckets in BLAST_DiagHash.

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.

Int4 BlastHspNumMax(Boolean gapped_calculation, const BlastHitSavingOptions *options)

Calculated the number of HSPs that should be saved.

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.

Int2 Blast_HSPListSaveHSP(BlastHSPList *hsp_list, BlastHSP *hsp)

Saves HSP information into a BlastHSPList structure.

#define PV_ARRAY_BTS

bits-to-shift from lookup_index to pv_array index.

#define PV_TEST(lookup, index, shift)

Test the bit at position 'index' in the PV array bitfield within 'lookup'.

#define PV_ARRAY_TYPE

The pv_array 'native' type.

Routines for creating nucleotide BLAST lookup tables.

#define NA_HITS_PER_CELL

maximum number of hits in one lookup table cell

Routines for scanning nucleotide BLAST lookup tables.

void * BlastChooseNucleotideScanSubjectAny(LookupTableWrap *lookup_wrap)

Return the most generic function to scan through nucleotide subject sequences.

Int4(* TNaScanSubjectFunction)(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Generic prototype for nucleotide subject scanning routines.

@ eSmallNaLookupTable

lookup table for blastn with small query

@ eMBLookupTable

megablast lookup table (includes both contiguous and discontiguous megablast)

@ eNaHashLookupTable

used for 16-base words

@ eDiagHash

use hash table (blastn only)

Int4 BSearchContextInfo(Int4 n, const BlastQueryInfo *A)

Search BlastContextInfo structures for the specified offset.

Various auxiliary BLAST utility functions.

#define NCBI2NA_UNPACK_BASE(x, N)

Macro to extract base N from a byte x (N >= 0, N < 4)

static void get_results(DBPROCESS *dbproc, int start)

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

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

ir_diag_hash * ir_hash_create(void)

Hash table constructor.

ir_diag_hash * ir_hash_destroy(ir_diag_hash *hash)

Hash table destructor.

Declarations of structures needed to implement diagonal hash to support ungapped extensions for index...

#define IR_LOCATE(hash, diag, key)

Find a hash table entry for the given diagonal.

#define IR_KEY(diag)

Compute the hash key from a diagonal identifier.

#define IR_DIAG(qoff, soff)

Compute diagonal identifier from subject and query offsets.

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

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.

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.

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.

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.

SubjectIndex * SubjectIndexFree(SubjectIndex *sindex)

Free subject index structure.

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

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

Convert Jumper's preliminary edit script to GapEditScript.

#define SUBJECT_INDEX_WORD_LENGTH

for(len=0;yy_str[len];++len)

if(yy_accept[yy_current_state])

Boolean(* T_Lookup_Callback)(const LookupTableWrap *, Int4, Int4)

Function pointer type to check the presence of index->q_off pair.

static NCBI_INLINE Boolean s_DetermineScanningOffsets(const BLAST_SequenceBlk *subject, Int4 word_length, Int4 lut_word_length, Int4 *range)

Determines the scanner's offsets taking the database masking restrictions into account (if any).

Declarations for functions that extract hits from indexed blast databases (specialized for megablast)

#define LAST_VOL_IDX_NULL

int(* T_MB_IdbCheckOid)(Int4 oid, Int4 *last_vol_id)

Function pointer type to check index seeds availability for oid.

unsigned long(* T_MB_IdbGetResults)(Int4 oid, Int4 chunk, BlastInitHitList *init_hitlist)

Function pointer type to retrieve hits from an indexed database.

static NCBI_INLINE Int4 s_BlastDiagHashRetrieve(BLAST_DiagHash *table, Int4 diag, Int4 *level, Int4 *hit_len, Int4 *hit_saved)

Attempt to retrieve information associated with diagonal diag.

static Boolean s_MBLookup(const LookupTableWrap *lookup_wrap, Int4 index, Int4 q_pos)

Check to see if an index->q_pos pair exists in MB lookup table.

static NCBI_INLINE Int4 s_BlastDiagHashInsert(BLAST_DiagHash *table, Int4 diag, Int4 level, Int4 len, Int4 hit_saved, Int4 s_off, Int4 window_size)

Attempt to store information associated with diagonal diag.

static Int4 s_BlastSmallNaExtendAlignedOneByte(const BlastOffsetPair *offset_pairs, Int4 num_hits, const BlastInitialWordParameters *word_params, LookupTableWrap *lookup_wrap, BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 **matrix, BlastQueryInfo *query_info, Blast_ExtendWord *ewp, BlastInitHitList *init_hitlist, Uint4 s_range)

Perform exact match extensions on the hits retrieved from small-query lookup tables.

static Int4 s_BlastnDiagTableExtendInitialHit(BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 q_off, Int4 s_off, BlastSeqLoc *query_mask, BlastQueryInfo *query_info, Int4 s_range, Int4 word_length, Int4 lut_word_length, const LookupTableWrap *lut, const BlastInitialWordParameters *word_params, Int4 **matrix, BLAST_DiagTable *diag_table, BlastInitHitList *init_hitlist, Boolean check_masks)

Perform ungapped extension given an offset pair, and save the initial hit information if the hit qual...

void BlastChooseNaExtend(LookupTableWrap *lookup_wrap)

Choose the best routine to use for creating ungapped alignments.

static NCBI_INLINE Boolean s_IsSeedMasked(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, Int4 s_off, Int4 lut_word_length, Int4 q_pos)

Test to see if seed->q_off exists in lookup table.

static Int4 s_BlastNaExtendAligned(const BlastOffsetPair *offset_pairs, Int4 num_hits, const BlastInitialWordParameters *word_params, LookupTableWrap *lookup_wrap, BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 **matrix, BlastQueryInfo *query_info, Blast_ExtendWord *ewp, BlastInitHitList *init_hitlist, Uint4 s_range)

Perform exact match extensions on the hits retrieved from blastn/megablast lookup tables,...

static Int4 s_BlastNaExtend(const BlastOffsetPair *offset_pairs, Int4 num_hits, const BlastInitialWordParameters *word_params, LookupTableWrap *lookup_wrap, BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 **matrix, BlastQueryInfo *query_info, Blast_ExtendWord *ewp, BlastInitHitList *init_hitlist, Uint4 s_range)

Perform exact match extensions on the hits retrieved from blastn/megablast lookup tables,...

static Int4 s_BlastSmallNaExtend(const BlastOffsetPair *offset_pairs, Int4 num_hits, const BlastInitialWordParameters *word_params, LookupTableWrap *lookup_wrap, BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 **matrix, BlastQueryInfo *query_info, Blast_ExtendWord *ewp, BlastInitHitList *init_hitlist, Uint4 s_range)

Perform exact match extensions on the hits retrieved from small-query blastn lookup tables,...

static void s_NuclUngappedExtend(BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 **matrix, Int4 q_off, Int4 s_match_end, Int4 s_off, Int4 X, BlastUngappedData *ungapped_data, const Int4 *score_table, Int4 reduced_cutoff)

Perform ungapped extension of a word hit.

Int2 BlastNaWordFinder(BLAST_SequenceBlk *subject, BLAST_SequenceBlk *query, BlastQueryInfo *query_info, LookupTableWrap *lookup_wrap, Int4 **matrix, const BlastInitialWordParameters *word_params, Blast_ExtendWord *ewp, BlastOffsetPair *offset_pairs, Int4 max_hits, BlastInitHitList *init_hitlist, BlastUngappedStats *ungapped_stats)

Find all words for a given subject sequence and perform ungapped extensions, assuming ordinary blastn...

static Boolean s_NaLookup(const LookupTableWrap *lookup_wrap, Int4 index, Int4 q_pos)

Check to see if an index->q_pos pair exists in Na lookup table.

static void s_NuclUngappedExtendExact(BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 **matrix, Int4 q_off, Int4 s_off, Int4 X, BlastUngappedData *ungapped_data)

Perform ungapped extension of a word hit, using a score matrix and extending one base at a time.

Int2 JumperNaWordFinder(BLAST_SequenceBlk *subject, BLAST_SequenceBlk *query, BlastQueryInfo *query_info, LookupTableWrap *lookup_wrap, const BlastInitialWordParameters *word_params, const BlastScoringParameters *score_params, const BlastHitSavingParameters *hit_params, BlastOffsetPair *offset_pairs, MapperWordHits *word_hits, Int4 max_hits, BlastGapAlignStruct *gap_align, BlastInitHitList *init_hitlist, BlastHSPList **hsp_list_ptr, BlastUngappedStats *ungapped_stats, BlastGappedStats *gapped_stats)

MapperWordHits * MapperWordHitsFree(MapperWordHits *wh)

static const Uint1 s_ExactMatchExtendRight[256]

Entry i of this list gives the number of pairs of bits that are zero in the bit pattern of i,...

static Int4 s_BlastNaExtendDirect(const BlastOffsetPair *offset_pairs, Int4 num_hits, const BlastInitialWordParameters *word_params, LookupTableWrap *lookup_wrap, BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 **matrix, BlastQueryInfo *query_info, Blast_ExtendWord *ewp, BlastInitHitList *init_hitlist, Uint4 s_range)

Perform ungapped extensions on the hits retrieved from blastn/megablast lookup tables,...

static Int4 s_TypeOfWord(BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 *q_off, Int4 *s_off, BlastSeqLoc *locations, BlastQueryInfo *query_info, Uint4 s_range, Uint4 word_length, Uint4 lut_word_length, const LookupTableWrap *lookup_wrap, Boolean check_double, Int4 *extended)

Check the mini-extended word against masked query regions, and do right extension if necessary.

MapperWordHits * MapperWordHitsNew(const BLAST_SequenceBlk *query, const BlastQueryInfo *query_info)

Int2 ShortRead_IndexedWordFinder(BLAST_SequenceBlk *subject, BLAST_SequenceBlk *query, BlastQueryInfo *query_info, LookupTableWrap *lookup_wrap, const BlastInitialWordParameters *word_params, const BlastScoringParameters *score_params, const BlastHitSavingParameters *hit_params, BlastOffsetPair *offset_pairs, MapperWordHits *word_hits, Int4 max_hits, BlastGapAlignStruct *gap_align, BlastInitHitList *init_hitlist, BlastHSPList **hsp_list, BlastUngappedStats *ungapped_stats, BlastGappedStats *gapped_stats)

static const Uint1 s_ExactMatchExtendLeft[256]

Entry i of this list gives the number of pairs of bits that are zero in the bit pattern of i,...

static Boolean s_SmallNaLookup(const LookupTableWrap *lookup_wrap, Int4 index, Int4 q_pos)

Check to see if an index->q_pos pair exists in SmallNa lookup table.

Int2 MB_IndexedWordFinder(BLAST_SequenceBlk *subject, BLAST_SequenceBlk *query, BlastQueryInfo *query_info, LookupTableWrap *lookup_wrap, Int4 **matrix, const BlastInitialWordParameters *word_params, Blast_ExtendWord *ewp, BlastOffsetPair *offset_pairs, Int4 max_hits, BlastInitHitList *init_hitlist, BlastUngappedStats *ungapped_stats)

Finds all runs of a specified number of exact matches between two nucleotide sequences.

static Int4 s_BlastnDiagHashExtendInitialHit(BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 q_off, Int4 s_off, BlastSeqLoc *query_mask, BlastQueryInfo *query_info, Int4 s_range, Int4 word_length, Int4 lut_word_length, const LookupTableWrap *lut, const BlastInitialWordParameters *word_params, Int4 **matrix, BLAST_DiagHash *hash_table, BlastInitHitList *init_hitlist, Boolean check_masks)

Perform ungapped extension given an offset pair, and save the initial hit information if the hit qual...

Nucleotide ungapped extension code.

Int4(* TNaExtendFunction)(const BlastOffsetPair *offset_pairs, Int4 num_hits, const BlastInitialWordParameters *word_params, LookupTableWrap *lookup_wrap, BLAST_SequenceBlk *query, BLAST_SequenceBlk *subject, Int4 **matrix, BlastQueryInfo *query_info, Blast_ExtendWord *ewp, BlastInitHitList *init_hitlist, Int4 range)

Signature of function used to compute ungapped alignments.

const struct ncbi::grid::netcache::search::fields::KEY key

#define MIN(a, b)

returns smaller of a and b.

#define NCBI_INLINE

"inline" seems to work on our remaining in-house compilers (WorkShop, Compaq, ICC,...

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 INT4_MIN

Smallest (most negative) number represented by signed int.

#define MAX(a, b)

returns larger of a and b.

Int4 delta(size_t dimension_, const Int4 *score_)

Track initial word matches using hashing with chaining.

Int4 offset

"offset" added to query and subject position so that "last_hit" doesn't have to be zeroed out every t...

Structure containing parameters needed for initial word extension.

DiagStruct * hit_level_array

Array to hold latest hits and their lengths for all diagonals.

Int4 diag_array_length

Smallest power of 2 longer than query length.

Int4 diag_mask

Used to mask off everything above min_diag_length (mask = min_diag_length-1).

Uint1 * hit_len_array

Array to hold the lengthof the latest hit.

Int4 offset

"offset" added to query and subject position so that "last_hit" doesn't have to be zeroed out every t...

Structure to hold a sequence.

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 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

JumperGapAlign * jumper

data for jumper alignment

Int4 score

Return value: alignment score.

GapEditScript * edit_script

The traceback (gap) information.

Structure containing hit counts from the gapped stage of a BLAST search.

Int4 extensions

Total number of gapped extensions performed.

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

JumperEditsBlock * edits

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

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.

BlastHSPMappingInfo * map_info

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

BlastHitSavingOptions * options

The original (unparsed) options.

Structure to hold the initial HSP information.

BlastUngappedData * ungapped_data

Pointer to a structure holding ungapped alignment information.

BlastOffsetPair offsets

Offsets in query and subject, or, in PHI BLAST, start and end of pattern in subject.

Structure to hold all initial HSPs for a given subject sequence.

Int4 total

Total number of hits currently saved.

BlastInitHSP * init_hsp_array

Array of offset pairs, possibly with scores.

EBlastProgramType program_number

indicates blastn, blastp, etc.

Int4 window_size

Maximal allowed distance between 2 hits in case 2 hits are required to trigger the extension.

Int4 scan_range

Maximal number of gaps allowed between 2 hits.

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

BlastUngappedCutoffs * cutoffs

cutoff values (one per context)

Boolean ungapped_extension

Should an ungapped extension be performed?

BlastInitialWordOptions * options

The original (unparsed) options.

Boolean matrix_only_scoring

Use the scoring matrix ( not table ) to score ungapped and gapped alignments -RMH-.

ESeedContainerType container_type

How to store offset pairs for initial seeds?

Int4 nucl_score_table[256]

the combined score of all match/mismatch combinations for aligning four bases

The lookup table structure used for Mega BLAST.

Int4 lut_word_length

number of letters in a lookup table word

Int4 pv_array_bts

The exponent of 2 by which pv_array is smaller than the backbone.

BlastSeqLoc * masked_locations

masked locations, only non-NULL for soft-masking.

Int4 * hashtable

Array of positions.

PV_ARRAY_TYPE * pv_array

Presence vector, used for quick presence check.

Boolean stride

is lookup table created with a stride

Int8 hashsize

= 4^(lut_word_length)

Int4 scan_step

Step size for scanning the database.

Int4 word_length

number of exact letter matches that will trigger an ungapped extension

Boolean discontiguous

Are discontiguous words used?

Int4 * next_pos

Extra positions stored here.

void * extend_callback

function for extending hits

Int4 template_length

Length of the discontiguous word template.

The basic lookup table structure for blastn searches.

Int4 scan_step

number of bases between successive words

BlastSeqLoc * masked_locations

masked locations, only non-NULL for soft-masking.

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.

void * extend_callback

function for extending hits

The query related information.

BlastContextInfo * contexts

Information per context.

int num_queries

Number of query sequences.

Int4 last_context

Index of the last element of the context array.

Uint4 max_length

Length of the longest among the concatenated queries.

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

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

Lookup table structure for blastn searches with small queries.

Int4 scan_step

number of bases between successive words

Int4 word_length

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

void * extend_callback

function for extending hits

BlastSeqLoc * masked_locations

masked locations, only non-NULL for soft-masking.

Int4 lut_word_length

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

All the ungapped cutoff values that can change from context to context.

Int4 reduced_nucl_cutoff_score

for blastn, a reduced cutoff score for use with approximate ungapped alignments

Int4 cutoff_score

Cutoff score for saving ungapped hits.

Int4 x_dropoff

Raw X-dropoff value used in the ungapped extension.

Structure to hold ungapped alignment information.

Int4 score

Score of the ungapped alignment.

Int4 length

Length of the ungapped alignment.

Int4 q_start

Start of the ungapped alignment in query.

Int4 s_start

Start of the ungapped alignment in subject.

Structure containing hit counts from the ungapped stage of a BLAST search.

Int4 good_init_extends

Number of successful initial extensions, i.e.

Structure for keeping initial word extension information.

BLAST_DiagHash * hash_table

Hash table and related parameters.

BLAST_DiagTable * diag_table

Diagonal array and related parameters.

Structure for keeping last hit information for a diagonal in a hash table, when eRight or eRightAndLe...

Int4 hit_len

The length of last hit.

signed int level

This hit's offset in the subject sequence.

unsigned int hit_saved

Whether or not this hit has been saved.

Uint4 next

Offset of next element in the chain.

Int4 diag

This hit's diagonal.

Structure for keeping last hit information for a diagonal.

signed int last_hit

Offset of the last hit.

unsigned int flag

Reset the next extension?

JumperPrelimEditBlock * left_prelim_block

JumperPrelimEditBlock * right_prelim_block

Wrapper structure for different types of BLAST lookup tables.

void * lookup_callback

function used to look up an index->q_off pair

void * lut

Pointer to the actual lookup table structure.

void * check_index_oid

function used to check if seeds for a given oid are present

ELookupTableType lut_type

What kind of a lookup table it is?

void * read_indexed_db

function used to retrieve hits from an indexed database

Int4 num_arrays

number of pair_arrays

BlastOffsetPair ** pair_arrays

lists of word hits

Int4 * last_diag

diagnal for the last word hit for each query context

Int4 array_size

size of each array

Int4 * last_pos

subject position for the last word hit for each query context

Int4 * num

number of hits in the list

Int4 divisor

divisor used to find pair_arrays index based on query offset

Index for a chunk of a subject sequence.

Uint4 qend

Right end (in the query) of the last seen seed on the diagonal.

Uint4 diag

Diagonal identifier.

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