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

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

lookup_header =

->lookup_header;

->alphabet_size = 26;

->alphabet_size = 28;

(

= 0;

<

->backbone_size;

++) {

(

->rps_backbone[

].num_used > 0) {

profile_header =

->profile_header;

num_pssm_rows =

->rps_seq_offsets[

->num_profiles];

(

= 0;

< num_pssm_rows + 1;

++) {

->rps_pssm[

] = pssm_start;

pssm_start +=

->alphabet_size;

(

= 0;

<

->num_buckets;

++) {

(

= 0;

<

->num_buckets;

++)

(

= 0;

<

->word_length;

++)

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[

]) {

backbone_occupancy++;

overflow_cells_needed +=

->thin_backbone[

][1];

(

->thin_backbone[

][1] > longest_chain)

longest_chain =

->thin_backbone[

][1];

->overflow_size = overflow_cells_needed;

->longest_chain = longest_chain;

thick_backbone_occupancy = backbone_occupancy - num_overflows;

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

printf(

,

->exact_matches);

printf(

,

->neighbor_matches);

->bone_type = bone_type;

(overflow_cells_needed > 0) {

(overflow_cells_needed,

(

));

(

= 0;

<

->backbone_size;

++) {

(

->thin_backbone[

] ) {

dest += overflow_cursor;

overflow_cursor +=

->thin_backbone[

][1];

(j=0; j <

->thin_backbone[

][1]; j++)

dest[j] =

->thin_backbone[

][j + 2];

(overflow_cells_needed > 0) {

(

= 0;

<

->backbone_size;

++) {

(

->thin_backbone[

] ) {

dest=((

*) (

->overflow))+overflow_cursor;

overflow_cursor +=

->thin_backbone[

][1];

(j=0; j <

->thin_backbone[

][1]; j++)

dest[j] =

->thin_backbone[

][j + 2];

**exact_backbone;

(

= 0;

<

->alphabet_size;

++) {

row_max[

] = matrix[

][0];

(j = 1; j <

->alphabet_size; j++)

row_max[

] =

(row_max[

], matrix[

][j]);

(

= 0;

<

->backbone_size;

++) {

(exact_backbone[

] !=

) {

exact_backbone[

], query_bias, row_max);

(exact_backbone[

]);

(exact_backbone);

->exact_matches += offset_list[1];

w =

+ offset_list[2];

score = matrix[w[0]][w[0]];

(

= 1;

<

->word_length;

++)

score += matrix[w[

]][w[

]];

(

->threshold == 0 || score < lookup->threshold) {

(

= 0;

< offset_list[1];

++) {

query_bias + offset_list[

+ 2]);

->neighbor_matches -= offset_list[1];

(

->threshold == 0)

.query_word = w;

.subject_word = s;

.matrix = matrix;

.row_max = row_max;

.offset_list = offset_list;

.query_bias = query_bias;

score = row_max[w[0]];

(

= 1;

<

->word_length;

++)

score += row_max[w[

]];

alphabet_size =

->alphabet_size;

*subject_word =

->subject_word;

score -=

->row_max[query_word[current_pos]];

=

->matrix[query_word[current_pos]];

(current_pos ==

->wordsize - 1) {

*offset_list =

->offset_list;

query_bias =

->query_bias;

(

= 0;

< alphabet_size;

++) {

(score +

[

] >= threshold) {

subject_word[current_pos] =

;

(j = 0; j < offset_list[1]; j++) {

charsize, subject_word,

query_bias + offset_list[j + 2]);

->neighbor_matches += offset_list[1];

(

= 0;

< alphabet_size;

++) {

(score +

[

] >= threshold) {

subject_word[current_pos] =

;

(

= 0;

< wordsize - 1;

++) {

row_max[

] =

[

][0];

(j = 1; j <

->alphabet_size; j++)

row_max[

] =

(row_max[

],

[

][j]);

row_max[wordsize - 1] =

[wordsize - 1][0];

(

= 1;

<

->alphabet_size;

++)

row_max[wordsize - 1] =

(row_max[wordsize - 1],

[wordsize - 1][

]);

(

= 0;

< wordsize - 1;

++)

row_max[

] = row_max[

+ 1];

.subject_word = s;

.matrix = matrix;

.row_max = row_max;

(

= 1;

<

->word_length;

++)

score += row_max[

];

alphabet_size =

->alphabet_size;

*subject_word =

->subject_word;

score -=

->row_max[current_pos];

=

->matrix[current_pos];

(current_pos ==

->wordsize - 1) {

(

= 0;

< alphabet_size;

++) {

(score +

[

] >= threshold) {

subject_word[current_pos] =

;

charsize, subject_word,

);

->neighbor_matches++;

(

= 0;

< alphabet_size;

++) {

(score +

[

] >= threshold) {

subject_word[current_pos] =

;

(

->curr_overflow_cell ==

bank_idx =

->curr_overflow_bank + 1;

->curr_overflow_bank++;

->curr_overflow_cell = 0;

->overflow_banks[

->curr_overflow_bank] +

->curr_overflow_cell++;

(num_entries) {

(cell_index == 0 ) {

W7p1[] = { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90};

W7p2[] = { 0, 100, 200, 300, 400, 500, 600, 700, 800,

W7p3[] = { 0, 1000, 2000, 3000, 4000, 5000, 6000,

W7p4[] = { 0, 10000, 20000, 30000, 40000, 50000, 60000,

70000, 80000, 90000};

W7p5[] = { 0, 100000, 200000, 300000, 400000, 500000,

600000, 700000, 800000, 900000};

W7p6[] = { 0, 1000000, 2000000, 3000000, 4000000,

5000000, 6000000, 7000000, 8000000, 9000000};

W6p1[] = { 0, 15, 30, 45, 60, 75, 90, 105, 120, 135,

150, 165, 180, 195, 210};

W6p2[] = { 0, 225, 450, 675, 900, 1125, 1350, 1575,

1800, 2025, 2250, 2475, 2700, 2925, 3150};

W6p3[] = { 0, 3375, 6750, 10125, 13500, 16875, 20250,

23625, 27000, 30375, 33750, 37125, 40500,

W6p4[] = { 0, 50625, 101250, 151875, 202500, 253125,

303750, 354375, 405000, 455625, 506250,

556875, 607500, 658125, 708750};

W6p5[] = { 0, 759375, 1518750, 2278125, 3037500,

3796875, 4556250, 5315625, 6075000, 6834375,

7593750, 8353125, 9112500, 9871875, 10631250};

(

->word_length) {

index = w[0] + W6p1[w[1]] + W6p2[w[2]] + W6p3[w[3]] + W6p4[w[4]];

index = w[0] + W6p1[w[1]] + W6p2[w[2]] + W6p3[w[3]] + W6p4[w[4]] + W6p5[w[5]];

index = w[0] + W7p1[w[1]] + W7p2[w[2]] + W7p3[w[3]] + W7p4[w[4]] + W7p5[w[5]] + W7p6[w[6]];

->compressed_alphabet_size,

longChar, shortChar;

(longChar = 0; longChar <

; longChar++) {

(shortChar = 0; shortChar <

->compressed_alphabet_size; shortChar++) {

sortTable[shortChar].

=

->row_max[longChar] -

->matrix[longChar][shortChar];

sortTable[shortChar].

= shortChar;

qsort(sortTable,

->compressed_alphabet_size,

(

= 0;

<

->compressed_alphabet_size;

++) {

->matrixSorted[longChar][

] =

->matrix[longChar][

];

*subject_word =

->subject_word;

currQueryChar = query_word[current_pos];

score -=

->row_max[currQueryChar];

rowSorted =

->matrixSorted[currQueryChar];

charSorted =

->matrixSortedChar[currQueryChar];

(current_pos ==

->wordsize - 1) {

query_offset =

->query_offset;

(

= 0;

<

->compressed_alphabet_size &&

(score + rowSorted[

] >=

->threshold);

++) {

subject_word[current_pos] = charSorted[

];

->neighbor_matches++;

(

= 0;

<

->compressed_alphabet_size &&

(score + rowSorted[

] >=

->threshold);

++) {

subject_word[current_pos] = charSorted[

];

->exact_matches++;

(

= 0;

<

->word_length;

++) {

c =

->compress_table[w[

]];

(c >=

->compressed_alphabet_size)

score +=

->matrix[w[

]][c];

(

->threshold == 0 || score < lookup->threshold) {

->neighbor_matches--;

(

->threshold == 0)

->query_word = w;

->subject_word = s;

->query_offset = query_offset;

score =

->row_max[w[0]];

(

= 1;

<

->word_length;

++)

score +=

->row_max[w[

]];

** compressed_matrix,

(

= 0;

<

->alphabet_size;

++) {

.row_max[

] = compressed_matrix[

][0];

(j = 1; j <

->compressed_alphabet_size; j++)

.row_max[

] =

(

.row_max[

], compressed_matrix[

][j]);

.compressed_alphabet_size =

->compressed_alphabet_size;

.matrix = compressed_matrix;

longest_chain = 0;

kTargetPVBytes = 262144;

histogram[HISTSIZE] = {0};

backbone_occupancy = 0;

num_overflows = 0;

(

->backbone[

].num_used)

(count <= 0.01 * lookup->backbone_size) {

pv_array_bts +=

(

->backbone_size / (8 * kTargetPVBytes));

(

->backbone_size >> pv_array_bts) + 1,

->pv_array_bts = pv_array_bts;

(

= 0;

<

->backbone_size;

++) {

(pv,

, pv_array_bts);

longest_chain =

(

, longest_chain);

(

>= HISTSIZE)

histogram[

]++;

->longest_chain = longest_chain;

backbone_occupancy =

->backbone_size - histogram[0];

printf(

,

->backbone_size);

printf(

, backbone_occupancy,

100.0 * backbone_occupancy /

->backbone_size);

printf(

, num_overflows);

printf(

, longest_chain);

printf(

,

->exact_matches);

printf(

,

->neighbor_matches);

printf(

,

->curr_overflow_bank + 1);

printf(

, 1 << (

->pv_array_bts -

printf(

);

(

= 0;

< HISTSIZE;

++) {

printf(

,

, histogram[

]);

kMatrixScale = 100.0;

(word_size == 5 || word_size == 6 || word_size == 7);

->word_length = word_size;

(word_size == 6 || word_size == 5) {

->compressed_alphabet_size = 15;

->reciprocal_alphabet_size = 286331154;

->compressed_alphabet_size = 10;

->reciprocal_alphabet_size = 429496730;

->compressed_alphabet_size,

(new_alphabet ==

)

->curr_overflow_bank = -1;

table_scale =

(

->compressed_alphabet_size, word_size - 1);

->scaled_compress_table[

] = -1;

->scaled_compress_table[

] = table_scale *

;

(

= 0;

<=

->curr_overflow_bank;

++) {

static void s_CompressedLookupAddEncoded(BlastCompressedAaLookupTable *lookup, Uint1 *w, Int4 query_offset)

Add a single query offset to the compressed lookup table.

static void s_CompressedAddNeighboringWords(BlastCompressedAaLookupTable *lookup, Int4 **compressed_matrix, BLAST_SequenceBlk *query, BlastSeqLoc *location)

Index a query sequence; i.e.

static Int4 s_CompressedLookupFinalize(BlastCompressedAaLookupTable *lookup)

Complete the construction of a compressed protein lookup table.

struct LetterAndScoreDifferencePair LetterAndScoreDifferencePair

Structure used as a helper for sorting matrix according to substitution score.

static void s_AddPSSMWordHitsCore(NeighborInfo *info, Int4 score, Int4 current_pos)

Add neighboring words to the lookup table in case of a position-specific matrix, using NeighborInfo s...

Int4 BlastCompressedAaLookupTableNew(BLAST_SequenceBlk *query, BlastSeqLoc *locations, BlastCompressedAaLookupTable **lut, const LookupTableOptions *opt, BlastScoreBlk *sbp)

Create a new compressed protein lookup table.

static void s_CompressedAddWordHits(CompressedNeighborInfo *info, Uint1 *query, Int4 query_offset)

Add neighboring words to the lookup table (compressed alphabet).

static void s_AddWordHits(BlastAaLookupTable *lookup, Int4 **matrix, Uint1 *query, Int4 *offset_list, Int4 query_bias, Int4 *row_max)

Add neighboring words to the lookup table.

BlastCompressedAaLookupTable * BlastCompressedAaLookupTableDestruct(BlastCompressedAaLookupTable *lookup)

Free the compressed lookup table.

BlastAaLookupTable * BlastAaLookupTableDestruct(BlastAaLookupTable *lookup)

Free the lookup table.

static CompressedOverflowCell * s_CompressedListGetNewCell(BlastCompressedAaLookupTable *lookup)

Fetch next vacant cell from a bank.

static void s_CompressedLookupAddWordHit(BlastCompressedAaLookupTable *lookup, Int4 index, Int4 query_offset)

Add a single query offset to the compressed alphabet protein lookup table.

BlastRPSLookupTable * RPSLookupTableDestruct(BlastRPSLookupTable *lookup)

Free the lookup table.

static void s_AddPSSMNeighboringWords(BlastAaLookupTable *lookup, Int4 **matrix, Int4 query_bias, BlastSeqLoc *location)

A position-specific version of AddNeighboringWords.

Int2 RPSLookupTableNew(const BlastRPSInfo *info, BlastRPSLookupTable **lut)

Create a new RPS blast lookup table.

struct CompressedNeighborInfo CompressedNeighborInfo

Structure containing information needed for adding neighboring words (specific to compressed lookup t...

static void s_CompressedLookupAddUnencoded(BlastCompressedAaLookupTable *lookup, Uint1 *w, Int4 query_offset)

Add a single query offset to the compressed lookup table.

static void s_AddWordHitsCore(NeighborInfo *info, Int4 score, Int4 current_pos)

Add neighboring words to the lookup table using NeighborInfo structure.

static void s_CompressedAddWordHitsCore(CompressedNeighborInfo *info, Int4 score, Int4 current_pos)

Very similar to s_AddWordHitsCore.

void BlastAaLookupIndexQuery(BlastAaLookupTable *lookup, Int4 **matrix, BLAST_SequenceBlk *query, BlastSeqLoc *location, Int4 query_bias)

Index a protein query.

Int4 BlastAaLookupFinalize(BlastAaLookupTable *lookup, EBoneType bone_type)

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

static void s_AddPSSMWordHits(BlastAaLookupTable *lookup, Int4 **matrix, Int4 query_bias, Int4 *row_max)

Add neighboring words to the lookup table in case of a position-specific matrix.

static void s_loadSortedMatrix(CompressedNeighborInfo *info)

Prepare "score sorted" version of the substitution matrix".

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

callback for the "sort"

Int4 BlastAaLookupTableNew(const LookupTableOptions *opt, BlastAaLookupTable **lut)

Create a new protein lookup table.

static void s_AddNeighboringWords(BlastAaLookupTable *lookup, Int4 **matrix, BLAST_SequenceBlk *query, Int4 query_bias, BlastSeqLoc *location)

Index a query sequence; i.e.

struct NeighborInfo NeighborInfo

Structure containing information needed for adding neighboring words.

Routines for creating protein BLAST lookup tables.

#define COMPRESSED_OVERFLOW_MAX_BANKS

The maximum number of banks (usually less than 10 are needed; memory will run out before this is insu...

#define COMPRESSED_HITS_PER_BACKBONE_CELL

number of query offsets to store in a backbone cell

#define COMPRESSED_HITS_CELL_MASK

#define RPS_BUCKET_SIZE

The number of regions into which the concatenated RPS blast database is split via bucket sorting.

#define AA_HITS_PER_CELL

maximum number of hits in one lookup table cell

#define COMPRESSED_OVERFLOW_CELLS_IN_BANK

number of cells in one bank of cells

static NCBI_INLINE Int4 s_ComputeCompressedIndex(Int4 wordsize, const Uint1 *word, Int4 compressed_alphabet_size, Int4 *skip, BlastCompressedAaLookupTable *lookup)

Convert a word to use a compressed alphabet.

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

void BlastLookupAddWordHit(Int4 **backbone, Int4 wordsize, Int4 charsize, Uint1 *seq, Int4 query_offset)

Add a single query offset to a generic lookup table.

#define PV_ARRAY_BTS

bits-to-shift from lookup_index to pv_array index.

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.

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

length of word to trigger an extension.

#define RPS_MAGIC_NUM_28

Version number for 28-letter alphabet.

#define RPS_MAGIC_NUM

RPS blast version number.

SCompressedAlphabet * SCompressedAlphabetFree(SCompressedAlphabet *alphabet)

Free a compressed alphabet and score matrix.

SCompressedAlphabet * SCompressedAlphabetNew(BlastScoreBlk *sbp, Int4 compressed_alphabet_size, double scale_factor)

Allocate a new compressed alphabet and score matrix.

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

static const char location[]

#define BLASTAA_SIZE

Size of aminoacid alphabet.

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

uint16_t Uint2

2-byte (16-bit) unsigned integer

Utility functions for lookup table generation.

Int4 iexp(Int4 x, Int4 n)

Integer exponentiation using right to left binary algorithm.

Int4 ilog2(Int8 x)

Integer base two logarithm.

#define ASSERT

macro for assert.

#define MAX(a, b)

returns larger of a and b.

#define row(bind, expected)

structure defining one cell of the compacted lookup table

union AaLookupBackboneCell::@3 payload

union that specifies either entries stored right on the backbone if fewer than AA_HITS_PER_CELL are p...

Int4 entries[3]

if the number of hits for this cell is AA_HITS_PER_CELL or less, the hits are all stored directly in ...

Int4 overflow_cursor

integer offset into the overflow array where the list of hits for this cell begins

Int4 num_used

number of hits stored for this cell

structure defining one cell of the small (i.e., use short) lookup table

union AaLookupSmallboneCell::@4 payload

union that specifies either entries stored right on the backbone if fewer than AA_HITS_PER_CELL are p...

Uint2 num_used

number of hits stored for this cell

Int4 overflow_cursor

integer offset into the overflow array where the list of hits for this cell begins

Uint2 entries[3]

if the number of hits for this cell is AA_HITS_PER_CELL or less, the hits are all stored directly in ...

Structure to hold a sequence.

The basic lookup table structure for blastp searches.

The lookup table structure for protein searches using a compressed alphabet.

The RPS engine uses this structure to access all of the RPS blast related data (assumed to be collect...

The basic lookup table structure for RPS blast searches.

Structure used for scoring calculations.

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 for hashtable of indexed query offsets

Int4 query_offsets[4]

storage for query offsets local to the backbone cell

CompressedMixedOffsets overflow_list

storage for remote query offsets

union CompressedLookupBackboneCell::@5 payload

structure for holding the list of query offsets

Int4 query_offsets[4 -2]

the query offsets stored locally

CompressedOverflowCell * head

head of linked list of cells of query offsets stored off the backbone

Structure containing information needed for adding neighboring words (specific to compressed lookup t...

Int4 matrixSorted[BLASTAA_SIZE][BLASTAA_SIZE]

version of substitution matrix whose rows are sorted by score

BlastCompressedAaLookupTable * lookup

Lookup table.

Int4 compressed_alphabet_size

for use with compressed alphabet

Int4 wordsize

number of residues in a word

Uint1 * subject_word

the computed neighboring word

Int4 ** matrix

the substitution matrix

Int4 query_offset

a single query offset to index

Uint1 matrixSortedChar[BLASTAA_SIZE][BLASTAA_SIZE]

matrix with the letters permuted identically to that of matrixSorted

Int4 threshold

the score threshold for neighboring words

Int4 row_max[BLASTAA_SIZE]

maximum possible score for each row of the matrix

Uint1 * query_word

the word whose neighbors we are computing

cell in list for holding query offsets

struct CompressedOverflowCell * next

pointer to next cell

Int4 query_offsets[4]

the query offsets stored in the cell

Structure used as a helper for sorting matrix according to substitution score.

Int4 diff

score difference from row maximum

Uint1 letter

given protein letter

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

Int4 word_size

Determines the size of the lookup table.

double threshold

Score threshold for putting words in a lookup table (fractional values are allowed,...

Structure containing information needed for adding neighboring words.

Int4 ** matrix

the substitution matrix

Uint1 * subject_word

the computed neighboring word

Int4 alphabet_size

number of letters in the alphabet

Uint1 * query_word

the word whose neighbors we are computing

Int4 threshold

the score threshold for neighboring words

Int4 charsize

number of bits in a residue

Int4 query_bias

bias all stored offsets for multiple queries

BlastAaLookupTable * lookup

Lookup table.

Int4 * row_max

maximum possible score for each row of the matrix

Int4 * offset_list

list of offsets where the word occurs in the query

Int4 wordsize

number of residues in a word

structure defining one cell of the RPS lookup table

structure used for bucket sorting offsets retrieved from the RPS blast lookup table.

Int4 num_filled

number of offset pairs currently in bucket

Int4 num_alloc

max number of offset pairs bucket can hold

BlastOffsetPair * offset_pairs

list of offset pairs

int ** data

actual scoring matrix data, stored in row-major form

Scoring matrix data used for compressed protein alphabets.

Uint1 * compress_table

translation table (AA->compressed)

SBlastScoreMatrix * matrix

score matrix

Int4 left

left endpoint of range (zero based)

Int4 right

right endpoint of range (zero based)

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

static Uint4 letter(char c)

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