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__nalookup_8c_source.html below:

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

approx_table_entries,

max_q_off,

(approx_table_entries < 250)

(approx_table_entries < 8500)

(approx_table_entries < 1250) {

}

(approx_table_entries < 21000) {

(approx_table_entries < 1250) {

}

(approx_table_entries < 8500) {

}

(approx_table_entries < 18000) {

(approx_table_entries < 12000) {

}

(approx_table_entries < 180000) {

(approx_table_entries < 8500) {

}

(approx_table_entries < 18000) {

}

(approx_table_entries < 60000) {

}

(approx_table_entries < 900000) {

(approx_table_entries < 8500) {

}

(approx_table_entries < 300000) {

(approx_table_entries >= 32767 || max_q_off >= 32768)) {

overflow_cells_needed = 2;

overflow_cursor = 2;

longest_chain = 0;

backbone_occupancy = 0;

thick_backbone_occupancy = 0;

num_overflows = 0;

(

= 0;

<

->backbone_size;

++) {

(thin_backbone[

] !=

) {

num_hits = thin_backbone[

][1];

overflow_cells_needed += num_hits + 1;

longest_chain =

(longest_chain, num_hits);

(overflow_cells_needed >= 32768) {

(

= 0;

<

->backbone_size;

++)

(thin_backbone[

]);

->longest_chain = longest_chain;

(overflow_cells_needed > 0) {

(

= 0;

<

->backbone_size;

++) {

(thin_backbone[

] ==

) {

->final_backbone[

] = -1;

backbone_occupancy++;

num_hits = thin_backbone[

][1];

thick_backbone_occupancy++;

->final_backbone[

] = thin_backbone[

][2];

->final_backbone[

] = -overflow_cursor;

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

->overflow[overflow_cursor++] =

thin_backbone[

][j + 2];

->overflow[overflow_cursor++] = -1;

(thin_backbone[

]);

->overflow_size = overflow_cursor;

printf(

);

printf(

,

->backbone_size);

printf(

, backbone_occupancy,

100.0 * backbone_occupancy /

->backbone_size);

printf(

,

thick_backbone_occupancy,

100.0 * thick_backbone_occupancy /

->backbone_size);

printf(

, num_overflows);

printf(

, overflow_cells_needed);

printf(

, longest_chain);

(stop - start > 2)

start = locations->

->

+1;

locations = locations->

;

stop = locations->

->

-1;

( !query_options ) {

**thin_backbone;

->lut_word_length = lut_width;

(thin_backbone);

(

->masked_locations)

overflow_cells_needed = 0;

overflow_cursor = 0;

longest_chain = 0;

backbone_occupancy = 0;

thick_backbone_occupancy = 0;

num_overflows = 0;

(

= 0;

<

->backbone_size;

++) {

(thin_backbone[

] !=

) {

num_hits = thin_backbone[

][1];

overflow_cells_needed += num_hits;

longest_chain =

(longest_chain, num_hits);

->longest_chain = longest_chain;

(overflow_cells_needed > 0) {

(

= 0;

<

->backbone_size;

++) {

(thin_backbone[

] ==

)

backbone_occupancy++;

num_hits = thin_backbone[

][1];

->thick_backbone[

].num_used = num_hits;

thick_backbone_occupancy++;

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

->thick_backbone[

].payload.entries[j] =

thin_backbone[

][j + 2];

->thick_backbone[

].payload.overflow_cursor =

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

->overflow[overflow_cursor] =

thin_backbone[

][j + 2];

(thin_backbone[

]);

->overflow_size = overflow_cursor;

printf(

,

->backbone_size);

printf(

, backbone_occupancy,

100.0 * backbone_occupancy /

->backbone_size);

printf(

,

thick_backbone_occupancy,

100.0 * thick_backbone_occupancy /

->backbone_size);

printf(

, num_overflows);

printf(

, overflow_cells_needed);

printf(

, longest_chain);

**thin_backbone;

->lut_word_length = lut_width;

(thin_backbone);

(

->masked_locations)

}

(length == 18) {

}

(length == 21) {

}

(

== 12) {

}

(length == 18) {

}

(length == 21) {

template_length;

kCompressionFactor=2048;

temp_int = template_type + 1;

second_template_type =

helper_array2 ==

)

from = loc->

->

- (template_length - 2);

to = loc->

->

- (template_length - 2);

pos = seq + template_length;

(index = from; index <= to; index++) {

pos = seq + template_length;

(pv_array, ecode1, pv_array_bts);

helper_array[ecode1/kCompressionFactor]++;

(pv_array, ecode2, pv_array_bts);

helper_array2[ecode2/kCompressionFactor]++;

(index = 0; index < mb_lt->

/ kCompressionFactor; index++)

longest_chain =

(longest_chain, helper_array[index]);

(helper_array);

(index = 0; index < mb_lt->

/ kCompressionFactor; index++)

longest_chain =

(longest_chain, helper_array2[index]);

(helper_array2);

seq =

->sequence_start + from;

pos = seq + kLutWordLength;

from -= kLutWordLength - 2;

last_offset = to + 2;

(index = from; index <= last_offset; index++) {

pos = seq + kLutWordLength;

(pv_array, ecode, pv_array_bts);

mb_lt->

[(

)((1 << (2 * word_size)) - 1)] = 0;

(word_size < 16) {

(

= 1;

< 4;

++) {

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

(

= 0;

< 3;

++) {

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

word = ((0xffffffff ^ (3 << k*2)) | (

<< k*2)) & 0xffffffff;

kCompressionFactor=2048;

* helper_array;

(helper_array ==

)

(lookup_options->

> 0) {

shift = lookup_options->

- 1;

pos_shift = kLutWordLength + 1;

seq =

->sequence_start + from;

pos = seq + kLutWordLength;

from -= kLutWordLength - 2;

last_offset = to + 2;

(index = from; index <= last_offset; index++) {

pos = seq + kLutWordLength;

((counts[ecode / 2] >> 4) >= max_word_count) {

((counts[ecode / 2] & 0xf) >= max_word_count) {

(pv_array, ecode, pv_array_bts);

helper_array[ecode/kCompressionFactor]++;

pos = seq + pos_shift;

(index = 0; index < mb_lt->

/ kCompressionFactor; index++)

longest_chain =

(longest_chain, helper_array[index]);

(helper_array);

max_word_count)

word, index, w;

kNumWords

(!sequence || !counts || !mb_lt || !pv) {

w = (

)s[0] << 24 | (

)s[1] << 16 | (

)s[2] << 8 | s[3];

(

= 0;

< kNumWords;

++) {

word = (w >> shift) &

;

(!

(pv, word, pv_array_bts)) {

((counts[index] & 0xf) < max_word_count) {

((counts[index] >> 4) < max_word_count) {

counts[index] += 1 << 4;

max_word_count)

(!seq_src || !pv || !counts) {

memset(&seq_arg, 0,

(seq_arg));

approx_table_entries,

kTargetPVSize = 131072;

kSmallQueryCutoff = 15000;

kLargeQueryCutoff = 800000;

(mb_lt ==

) {

(mb_lt->

<= 8 * kTargetPVSize)

(approx_table_entries <= kSmallQueryCutoff ||

approx_table_entries >= kLargeQueryCutoff)) {

pv_size = pv_size / 2;

(counts ==

) {

(lookup_options->

&& counts) {

printf(

, mb_lt->

,

printf(

,

fnv_prime = 16777619u;

fnv_offset_basis = 2166136261u;

= fnv_offset_basis;

(

= 0;

< 4;

++) {

lut_word_length;

pv_array_bts =

->pv_array_bts;

word_length =

->word_length;

lut_word_length =

->lut_word_length;

(loc = locations; loc; loc = loc->

) {

seq =

->sequence + from;

pos = seq + lut_word_length - 1;

end =

->sequence + to + 1;

(; seq < end; seq++) {

pos = seq + lut_word_length;

v = v - ((v >> 1) & 0x55555555);

v = (v & 0x33333333) + ((v >> 2) & 0x33333333);

v = ((v + (v >> 4)) & 0xF0F0F0F);

(

->values) {

(

->counts) {

(!retval || !bitfield) {

(

= 1;

< retval->

;

++) {

bit_count = (idx > 0) ?

->counts[idx - 1] : 0;

(

->bitfield[idx] & (1 << bit_number));

bit_count +=

(

->bitfield[idx] & ((1 << bit_number) - 1));

bit_count - 1;

(sparse_index < array->num_elements);

(sparse_index < 0 || sparse_index >

->num_elements) {

->values + sparse_index;

max_word_count)

kNumWords

(!sequence || !counts || !

|| !pv) {

w = (

)s[0] << 24 | (

)s[1] << 16 | (

)s[2] << 8 | s[3];

(

= 0;

< kNumWords;

++) {

word = (w >> shift) &

;

(!

(pv, word, pv_array_bts)) {

(*pelem < max_word_count) {

(

->seq_arg) {

(

= 0;

<

->num_threads;

++) {

(

= 0;

<

->num_threads;

++) {

(

->seq_src) {

(

= 0;

<

->num_threads;

++) {

(

->word_counts) {

(

= 1;

<

->num_threads;

++) {

(

->word_counts[

]) {

(

->word_counts[

]->values) {

(

->word_counts[

]->values);

(

->word_counts[

]);

(

->word_counts);

(num_threads < 1 || !

|| !seq_src) {

(!retval->

) {

(

= 0;

< num_threads;

++) {

(!retval->

[

]) {

1LL << (2 *

->lut_word_length));

in_num_threads,

max_word_count)

num_db_seqs, th_batch;

num_threads =

(in_num_threads, num_db_seqs);

(

= 0;

< num_threads;

++) {

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

th_data->

[

]);

(k = 1;k < num_threads;k++) {

(i < th_data->word_counts[0]->length) {

(k < th_data->word_counts[0]->num_elements);

pv_array_bts =

->pv_array_bts;

word_size =

->lut_word_length;

pv[0xffffffff >> pv_array_bts] &=

(

= 1;

< 4;

++) {

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

pv[word >> pv_array_bts] &=

(

= 0;

< 3;

++) {

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

word = ((0xffffffff ^ (3 << k*2)) | (

<< k*2)) & 0xffffffff;

pv[word >> pv_array_bts] &=

overflow_cells_needed = 0;

overflow_cursor = 0;

longest_chain = 0;

pv_array_bts =

->pv_array_bts;

kNumWords = 1LL << (2 *

->lut_word_length);

backbone_occupancy = 0;

thick_backbone_occupancy = 0;

num_overflows = 0;

words_per_hash[5] = {0,};

memset(

->pv, 0, (kNumWords >>

->pv_array_bts) *

(

= 0;

<

->backbone_size;

++) {

(

->num_offsets > 0) {

(;

;

=

->next) {

num_hits +=

->num_offsets;

overflow_cells_needed += num_hits + (num_words * 2);

longest_chain =

(longest_chain, num_hits);

->longest_chain = longest_chain;

(overflow_cells_needed > 0) {

(

= 0;

<

->backbone_size;

++) {

num_offsets = 0;

(

->num_offsets == 0) {

thick_backbone_occupancy++;

(

=

;

;

=

->next) {

num_offsets +=

->num_offsets;

backbone_occupancy++;

words_per_hash[((num_words < 6) ? num_words : 5) - 1]++;

(

=

;

;

=

->next, k++) {

cell->

[k] =

->word;

(

=

;

;

=

->next, k++) {

cell->

[k] =

->word;

is_overflow =

;

is_overflow =

;

cell->

[0] = overflow_cursor;

(

=

;

;

=

->next) {

->overflow[overflow_cursor++] = *(

*)(&

->word);

->overflow[overflow_cursor++] =

->num_offsets;

->overflow[overflow_cursor++] = j - 1;

(overflow_cursor <= overflow_cells_needed);

->offsets_size = overflow_cursor;

printf(

,

->backbone_size);

printf(

, backbone_occupancy,

100.0 * backbone_occupancy /

->backbone_size);

printf(

,

thick_backbone_occupancy,

100.0 * thick_backbone_occupancy /

->backbone_size);

printf(

, num_overflows);

printf(

);

(ii = 0;ii < 5;ii++) {

printf(

, ii + 1, words_per_hash[ii]);

printf(

, overflow_cells_needed);

printf(

, longest_chain);

(

->masked_locations)

kNumWords = (1ULL << 32);

num_hash_bits = 8;

, num_unique_words = 0;

->lut_word_length = 16;

(

= 0;i < kNumWords >>

->pv_array_bts;

++) {

(num_hash_bits < 32 &&

(1LL << num_hash_bits) < num_unique_words) {

->backbone_size = 1 << num_hash_bits;

(!thin_backbone) {

->lut_word_length,

(thin_backbone);

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

Declarations of static arrays used to define some NCBI encodings to be used in a toolkit independent ...

BLAST filtering functions.

BlastSeqLoc * BlastSeqLocFree(BlastSeqLoc *loc)

Deallocate all BlastSeqLoc objects in a chain.

BlastSeqLoc * BlastSeqLocNew(BlastSeqLoc **head, Int4 from, Int4 to)

Create and initialize a new sequence interval.

#define PV_ARRAY_BTS

bits-to-shift from lookup_index to pv_array index.

BackboneCell * BackboneCellFree(BackboneCell *cell)

#define PV_TEST(lookup, index, shift)

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

#define PV_ARRAY_MASK

amount to mask off.

void BlastLookupIndexQueryExactMatches(Int4 **backbone, Int4 word_length, Int4 charsize, Int4 lut_word_length, BLAST_SequenceBlk *query, BlastSeqLoc *locations)

Add all applicable query offsets to a generic lookup table.

void BlastHashLookupIndexQueryExactMatches(BackboneCell *backbone, Int4 *offsets, Int4 word_length, Int4 charsize, Int4 lut_word_length, BLAST_SequenceBlk *query, BlastSeqLoc *locations, TNaLookupHashFunction hash_func, Uint4 mask, Uint4 *pv_array)

Add all applicable query offsets to a hashed lookup table.

#define PV_ARRAY_BYTES

number of BYTES in 'native' type.

#define PV_SET(lookup, index, shift)

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

#define PV_ARRAY_TYPE

The pv_array 'native' type.

#define BLASTERR_MEMORY

System error: out of memory condition.

static Int2 s_NaHashLookupCountWordsInSubject_16_1(const BLAST_SequenceBlk *sequence, BlastNaHashLookupTable *lookup, BlastSparseUint1Array *counts, Uint1 max_word_count)

Scan a subject sequecne and update words counters, for 16-base words with scan step of 1.

BlastSmallNaLookupTable * BlastSmallNaLookupTableDestruct(BlastSmallNaLookupTable *lookup)

Free a small nucleotide lookup table.

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.

static Int4 s_BlastSmallNaLookupFinalize(Int4 **thin_backbone, BlastSmallNaLookupTable *lookup, BLAST_SequenceBlk *query)

Pack the data structures comprising a small nucleotide lookup table into their final form.

static Int2 s_FillContigMBTable(BLAST_SequenceBlk *query, BlastSeqLoc *location, BlastMBLookupTable *mb_lt, const LookupTableOptions *lookup_options, Uint1 *counts)

Fills in the hashtable and next_pos fields of BlastMBLookupTable* for the contiguous case.

static Boolean s_HasMaskAtHashEnabled(const QuerySetUpOptions *query_options)

Determine whether mask at hash is enabled from the QuerySetUpOptions.

static NaHashLookupThreadData * NaHashLookupThreadDataFree(NaHashLookupThreadData *th)

BlastMBLookupTable * BlastMBLookupTableDestruct(BlastMBLookupTable *mb_lt)

Deallocate memory used by the Mega BLAST lookup table.

static BlastSeqLoc * s_SeqLocListInvert(const BlastSeqLoc *locations, Int4 length)

Changes the list of locations into a list of the intervals between locations (the inverse).

static Int2 s_ScanSubjectForWordCounts(BlastSeqSrc *seq_src, BlastMBLookupTable *mb_lt, Uint1 *counts, Uint1 max_word_count)

Scan database sequences and count query words that appear in the database.

BlastNaHashLookupTable * BlastNaHashLookupTableDestruct(BlastNaHashLookupTable *lookup)

Free a nucleotide lookup table.

static BlastSparseUint1Array * BlastSparseUint1ArrayFree(BlastSparseUint1Array *array)

static EDiscTemplateType s_GetDiscTemplateType(Int4 weight, Uint1 length, EDiscWordType type)

Convert weight, template length and template type from input options into an MBTemplateType enum.

ELookupTableType BlastChooseNaLookupTable(const LookupTableOptions *lookup_options, Int4 approx_table_entries, Int4 max_q_off, Int4 *lut_width)

choose the type of nucleotide lookup table to be used for a blast search

Int2 BlastMBLookupTableNew(BLAST_SequenceBlk *query, BlastSeqLoc *location, BlastMBLookupTable **mb_lt_ptr, const LookupTableOptions *lookup_options, const QuerySetUpOptions *query_options, Int4 approx_table_entries, Int4 lut_width, BlastSeqSrc *seqsrc)

Create the lookup table for Mega BLAST.

Int4 BlastNaHashLookupTableNew(BLAST_SequenceBlk *query, BlastSeqLoc *locations, BlastNaHashLookupTable **lut, const LookupTableOptions *opt, const QuerySetUpOptions *query_options, BlastSeqSrc *seqsrc, Uint4 num_threads)

struct NaHashLookupThreadData NaHashLookupThreadData

static BlastSparseUint1Array * BlastSparseUint1ArrayNew(Uint4 *bitfield, Int8 len)

static Int2 s_NaHashLookupScanSubjectForWordCounts(BlastSeqSrc *seq_src, BlastNaHashLookupTable *lookup, Uint4 in_num_threads, Uint1 max_word_count)

Scan database sequences and count query words that appear in the database.

static void s_BlastNaHashLookupFinalize(BackboneCell *thin_backbone, Int4 *offsets, BlastNaHashLookupTable *lookup)

Pack the data structures comprising a nucleotide lookup table into their final form.

static Int2 s_NaHashLookupFillPV(BLAST_SequenceBlk *query, BlastSeqLoc *locations, BlastNaHashLookupTable *lookup)

static Uint4 s_Popcount(Uint4 v)

static Uint1 * BlastSparseUint1ArrayGetElement(BlastSparseUint1Array *array, Int8 index)

static Int4 BlastSparseUint1ArrayGetIndex(BlastSparseUint1Array *array, Int8 index)

#define BLAST2NA_MASK

bitfield used to detect ambiguities in uncompressed nucleotide letters

static Int2 s_FillPV(BLAST_SequenceBlk *query, BlastSeqLoc *location, BlastMBLookupTable *mb_lt, const LookupTableOptions *lookup_options)

static void s_BlastNaLookupFinalize(Int4 **thin_backbone, BlastNaLookupTable *lookup)

Pack the data structures comprising a nucleotide lookup table into their final form.

static Int2 s_NaHashLookupRemovePolyAWords(BlastNaHashLookupTable *lookup)

static Int2 s_MBCountWordsInSubject_16_1(const BLAST_SequenceBlk *sequence, BlastMBLookupTable *mb_lt, Uint1 *counts, Uint1 max_word_count)

Scan a subject sequecne and update words counters, for 16-base words with scan step of 1.

#define BITS_PER_NUC

number of bits in a compressed nucleotide letter

static Int2 s_FillDiscMBTable(BLAST_SequenceBlk *query, BlastSeqLoc *location, BlastMBLookupTable *mb_lt, const LookupTableOptions *lookup_options)

Fills in the hashtable and next_pos fields of BlastMBLookupTable* for the discontiguous case.

static NaHashLookupThreadData * NaHashLookupThreadDataNew(Int4 num_threads, BlastNaHashLookupTable *lookup, BlastSeqSrc *seq_src)

struct BlastSparseUint1Array BlastSparseUint1Array

Sparse array of Uint1 implemented with a bitfield.

static Int2 s_RemovePolyAWords(BlastMBLookupTable *mb_lt)

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

Create a new small nucleotide lookup table.

static Uint4 FNV_hash(Uint1 *seq, Uint4 mask)

BlastNaLookupTable * BlastNaLookupTableDestruct(BlastNaLookupTable *lookup)

Free a nucleotide lookup table.

Routines for creating nucleotide BLAST lookup tables.

#define NA_OFFSETS_PER_HASH

EDiscWordType

General types of discontiguous word templates.

#define NA_WORDS_PER_HASH

static NCBI_INLINE Int4 ComputeDiscontiguousIndex(Uint8 accum, EDiscTemplateType template_type)

Given an accumulator containing packed bases, compute the discontiguous word index specified by templ...

EDiscTemplateType

Enumeration of all discontiguous word templates; the enumerated values encode the weight,...

@ eDiscTemplate_12_18_Optimal

@ eDiscTemplate_11_18_Optimal

@ eDiscTemplateContiguous

@ eDiscTemplate_12_16_Optimal

@ eDiscTemplate_12_16_Coding

@ eDiscTemplate_11_21_Coding

@ eDiscTemplate_11_18_Coding

@ eDiscTemplate_12_21_Coding

@ eDiscTemplate_11_16_Optimal

@ eDiscTemplate_11_21_Optimal

@ eDiscTemplate_12_21_Optimal

@ eDiscTemplate_12_18_Coding

@ eDiscTemplate_11_16_Coding

#define NA_HITS_PER_CELL

maximum number of hits in one lookup table cell

Boolean SBlastFilterOptionsMaskAtHash(const SBlastFilterOptions *filter_options)

Queries whether masking should be done only for the lookup table or for the entire search.

ELookupTableType

Types of the lookup table.

@ eSmallNaLookupTable

lookup table for blastn with small query

@ eNaLookupTable

blastn lookup table

@ eMBLookupTable

megablast lookup table (includes both contiguous and discontiguous megablast)

@ eNaHashLookupTable

used for 16-base words

Boolean Blast_ProgramIsMapping(EBlastProgramType p)

Int4 BlastSeqSrcIteratorNext(const BlastSeqSrc *seq_src, BlastSeqSrcIterator *itr)

Increments the BlastSeqSrcIterator.

BlastSeqSrcIterator * BlastSeqSrcIteratorFree(BlastSeqSrcIterator *itr)

Frees the BlastSeqSrcIterator structure.

BlastSeqSrcIterator * BlastSeqSrcIteratorNewEx(unsigned int chunk_sz)

Allocate and initialize an iterator over a BlastSeqSrc.

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

Deallocate individual sequence.

BlastSeqSrc * BlastSeqSrcCopy(const BlastSeqSrc *seq_src)

Copy function: needed to guarantee thread safety.

Int4 BlastSeqSrcGetNumSeqs(const BlastSeqSrc *seq_src)

Get the number of sequences contained in the sequence source.

BlastSeqSrc * BlastSeqSrcFree(BlastSeqSrc *seq_src)

Frees the BlastSeqSrc structure by invoking the destructor function set by the user-defined construct...

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

Retrieve an individual sequence.

#define BLAST_SEQSRC_EOF

No more sequences available.

void BlastSeqSrcResetChunkIterator(BlastSeqSrc *seq_src)

Reset the internal "bookmark" of the last chunk for iteration provided by this object.

Various auxiliary BLAST utility functions.

BLAST_SequenceBlk * BlastSequenceBlkFree(BLAST_SequenceBlk *seq_blk)

Deallocate memory for a sequence block.

Int2 BlastCompressBlastnaSequence(BLAST_SequenceBlk *seq_blk)

Adds a specialized representation of sequence data to a sequence block.

ncbi::TMaskedQueryRegions mask

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

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

static const char location[]

@ eBlastEncodingProtein

NCBIstdaa.

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

int64_t Int8

8-byte (64-bit) signed integer

uint64_t Uint8

8-byte (64-bit) unsigned integer

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

Utility functions for lookup table generation.

Int4 ilog2(Int8 x)

Integer base two logarithm.

#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 PCRE2_SIZE * offsets

Structure to hold a sequence.

Int4 length

Length of sequence.

Uint1 * sequence

Sequence used for search (could be translation).

Thin backbone cell for nucleotide lookup table with hashed words.

The lookup table structure used for Mega BLAST.

Int4 num_words_added

Number of words added to the l.t.

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

Extra positions for the second template.

Int4 * hashtable2

Array of positions for second template.

Int4 * hashtable

Array of positions.

Int4 num_unique_pos_added

Number of positions added to the l.t.

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)

EDiscTemplateType template_type

Type of the discontiguous word template.

Int4 scan_step

Step size for scanning the database.

Int4 longest_chain

Largest number of query positions for a given word.

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.

Boolean two_templates

Use two templates simultaneously.

EDiscTemplateType second_template_type

Type of the second discontiguous word template.

Int4 template_length

Length of the discontiguous word template.

The basic lookup table structure for blastn searches.

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

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.

BLAST_SequenceBlk * seq

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

Complete type definition of Blast Sequence Source Iterator.

Complete type definition of Blast Sequence Source ADT.

Lookup table structure for blastn searches with small queries.

Sparse array of Uint1 implemented with a bitfield.

Uint1 * values

array of values for present indices

Uint4 num_elements

number of values present in the array

Int4 * counts

cumulative number of bits set

Uint4 length

length of the bitfield

Uint4 * bitfield

bitfield with bits set for present indices

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

Int4 word_size

Determines the size of the lookup table.

Uint1 max_db_word_count

words with larger frequency in the database will be masked in the lookup table, if the db_filter opto...

Boolean db_filter

scan the database and include only words that appear in the database between 1 and 9 times (currently...

EBlastProgramType program_number

indicates blastn, blastp, etc.

Int4 mb_template_type

Type of a discontiguous word template.

Uint4 stride

number of words to skip after collecting each word

Int4 mb_template_length

Length of the discontiguous words.

Structure defining one cell of the compacted lookup table.

Int1 num_offsets[3]

number of offsets for each word if there are fewer than 3

Uint4 words[3]

words stored under this hash value

Int4 offsets[9]

offset locations for each word

Int1 num_words

number of words stored under the same hash value

BlastSeqSrcIterator ** itr

BlastSparseUint1Array ** word_counts

BlastSeqSrcGetSeqArg * seq_arg

structure defining one cell of the compacted lookup table

Options required for setting up the query sequence.

char * filter_string

DEPRECATED, filtering options above.

SBlastFilterOptions * filtering_options

structured options for all filtering offered from algo/blast/core for BLAST.

Int4 left

left endpoint of range (zero based)

Int4 right

right endpoint of range (zero based)

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