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

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

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

temp_sub_score = 0;

temp_indel_score = 0;

*editInstructions;

editStep, nextEditStep;

gapCost = gapOpen + gapExtend;

band = highDiag-lowDiag+1;

(index1 = 1; index1 <= end1; index1++)

rightd = highDiag-lowDiag+1;

score_array[leftd].

= 0;

[0][leftd] = -1;

initialScore = -gapOpen;

(diagIndex = leftd+1; diagIndex <= rightd; diagIndex++) {

score_array[diagIndex].

= initialScore = initialScore-gapExtend;

score_array[diagIndex-1].

= initialScore-gapCost;

score_array[rightd+1].

= kMinScore;

score_array[rightd].

= kMinScore;

score_array[leftd-1].

= -gapCost;

score_array[leftd-1].

= kMinScore;

(

= 1;

<= end1;

++) {

(

> end2-highDiag)

matrixRow = matrix[seq1[

]];

temp_indel_score = score_array[leftd].

;

((index2 = leftd+lowDiag-1+

) > 0)

temp_sub_score = score_array[leftd].best+matrixRow[seq2[index2]];

(temp_indel_score > temp_sub_score || index2 <= 0) {

temp_sub_score = temp_indel_score;

tempHorScore = temp_sub_score-gapCost;

((temp_indel_score-= gapExtend) >= tempHorScore) {

score_array[leftd-1].

= temp_indel_score;

score_array[leftd-1].

= tempHorScore;

stateRow = &

[

][leftd];

*stateRow++ = nextState;

score_array[leftd].

= temp_sub_score;

(curd=leftd+1, score_row = &score_array[curd]; curd <= rightd; curd++) {

temp_sub_score = score_row->

+ matrixRow[seq2[curd+lowDiag-1+

]];

((temp_indel_score=score_row->

) > temp_sub_score) {

(temp_indel_score > tempHorScore) {

score_row->

= temp_indel_score;

tempHorScore -= gapExtend;

(score_row++-1)->best_gap = temp_indel_score-gapExtend;

score_row->

= tempHorScore;

tempHorScore -= gapExtend;

(score_row++-1)->best_gap = temp_indel_score-gapExtend;

}

(tempHorScore > temp_sub_score) {

score_row->

= tempHorScore;

tempHorScore -= gapExtend;

(score_row++-1)->best_gap = temp_indel_score-gapExtend;

score_row->

= temp_sub_score;

((temp_sub_score -= gapCost) >

(tempHorScore-=gapExtend)) {

tempHorScore = temp_sub_score;

(temp_sub_score > (temp_indel_score -= gapExtend)) {

*stateRow++= nextState;

(score_row++-1)->best_gap = temp_sub_score;

(score_row++-1)->best_gap = temp_indel_score;

score = (score_row-1)->best;

editInstructions = (

*)

(end1+end2);

(index1 = end1, diagIndex = rightd, editStep=0, charCounter = 0;

index1>=0; index1--, charCounter++) {

(stateDecoder == -1)

editInstructions[charCounter] = editStep = nextEditStep;

(charIndex = charCounter-1; charIndex >= 0; charIndex--) {

(editInstructions[charIndex]) {

(editInstructions);

(length <= 0 ? 0 : (gap_open + gap_extend*length));

lowDiag =

(

(-start1, lowDiag),

(start2-start1,0));

highDiag =

(

(start2, highDiag),

(start2-start1,0));

-

(gapOpen, gapExtend, start1);

-

(gapOpen, gapExtend, start2);

((highDiag-lowDiag+1) <= 1) {

(

= 1;

<= start1;

++) {

score += matrix[seq1[

]][seq2[

]];

score =

(seq1, seq2, start1, start2, lowDiag, highDiag, matrix,

gapOpen, gapExtend, alignScript);

prefixMatchedBitPattern = 0;

maskShiftPlus1 = (

<< 1) +1;

(

= 0, prefixMatchedBitPattern= 0;

<

;

++) {

prefixMatchedBitPattern =

((prefixMatchedBitPattern << 1) | maskShiftPlus1) &

&rightOne, &rightMaskOnly);

*start = rightMaskOnly + 1;

*prefixMatchedBitPattern;

prefixMatchedBitPattern = (

*)

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

prefixMatchedBitPattern[wordIndex] = 0;

(

= 0;

<

;

++) {

prefixMatchedBitPattern,

(wordIndex = 0; (wordIndex < num_words) && (!found);

((prefixMatchedBitPattern[wordIndex]>>j) % 2 == 1)

((multiword_items->

[wordIndex] >> j)%2 == 1)

(prefixMatchedBitPattern);

*start = rightMaskOnly+1;

wordIndex, wordIndex2;

twiceHitsOneWord;

(wordIndex = 1; wordIndex < num_words; wordIndex++) {

(j = 0; j <

; j += wordIndex) {

lastOffset = hitArray[j+wordIndex-1];

(hitIndex = 0; hitIndex < twiceHitsOneWord;

hitIndex+= 2, pos+= wordIndex+1) {

(wordIndex2 = 0; wordIndex2 < wordIndex; wordIndex2++)

hitArray1[pos+wordIndex2] = hitArray[j+wordIndex2];

hitArray1[pos+wordIndex2] = hitArray1[pos+wordIndex2-1] +

oneWordHitArray[hitIndex] + 1;

(j = 0; j < pos; j++)

hitArray[j] = hitArray1[j];

(j = 0; j < pos; j+= num_words) {

(hitArray[j+num_words-1] ==

) {

(

= 0;

< num_words;

++)

hitArray[

] = hitArray[

+j];

kBandLow = -5;

kBandHigh = 5;

startQueryMatch, endQueryMatch;

startDbMatch, endDbMatch;

queryMatchOffset, dbMatchOffset;

patternPosQuery, patternPosDb;

** matrix = score_matrix->

;

gap_open = score_options->

;

endQueryMatch = lenQuerySeq - 1;

endDbMatch = lenDbSeq - 1;

&endQueryMatch, pattern_blk);

&endDbMatch, pattern_blk);

&endQueryMatch, pattern_blk);

&endDbMatch, pattern_blk);

QueryWord, DbWord;

QueryVarSize, DbVarSize;

queryMatchOffset = dbMatchOffset = 0;

QueryWord = DbWord = 0;

QueryVarSize = DbVarSize = 0;

placeIndex < extra_items->

; placeIndex++) {

(patternWord < 0) {

QueryVarSize += hitArray1[QueryWord] -

hitArray1[QueryWord-1] -

DbVarSize += hitArray2[DbWord] -

hitArray2[DbWord-1] -

(QueryVarSize || DbVarSize) {

(QueryVarSize == DbVarSize) {

QueryVarSize, DbVarSize,

kBandLow, kBandHigh, matrix,

gap_open, gap_extend, alignScript);

queryMatchOffset += QueryVarSize;

querySeq += QueryVarSize;

dbMatchOffset += DbVarSize;

QueryVarSize = DbVarSize = 0;

(queryMatchOffset + QueryVarSize >= hitArray1[QueryWord])

(dbMatchOffset + DbVarSize >= hitArray2[DbWord])

(patternPosQuery = startQueryMatch, patternPosDb = startDbMatch;

patternPosQuery <= endQueryMatch || patternPosDb <= endDbMatch; ) {

(queryMatchOffset =0;

patternPosQuery <= endQueryMatch;

patternPosQuery++, queryMatchOffset++) ;

(dbMatchOffset = 0;

patternPosDb <= endDbMatch;

patternPosDb++, dbMatchOffset++) ;

(queryMatchOffset == dbMatchOffset) {

}

(queryMatchOffset > 0);

(querySeq-1, dbSeq-1, queryMatchOffset, dbMatchOffset,

kBandLow, kBandHigh, matrix, gap_open, gap_extend,

querySeq+=queryMatchOffset;

dbSeq+=dbMatchOffset;

query_offset,

subject_offset,

query_length,

subject_length)

found_start, found_end;

q_length=0, s_length=0, score_right, score_left;

private_q_start, private_s_start;

(gap_align ==

)

q_length = query_offset;

s_length = subject_offset;

found_start =

;

(q_length != 0 && s_length != 0) {

&private_q_start, &private_s_start,

,

, gap_align,

gap_align->

= q_length - private_q_start + 1;

q_length += query_length - 1;

s_length += subject_length - 1;

(q_length < query_blk->length && s_length < subject_blk->length) {

(found_start ==

) {

(found_end ==

) {

gap_align->

= query_offset + query_length;

gap_align->

= subject_offset + subject_length;

gap_align->

= score_right+score_left;

(!

|| !

|| !gap_align || !score_params ||

!hit_params || !init_hitlist || !hsp_list_ptr)

(init_hitlist->

== 0)

hit_options = hit_params->

;

(*hsp_list_ptr ==

)

hsp_list = *hsp_list_ptr;

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

(index=0; index<init_hitlist->

; index++) {

s_pat_offset, s_pat_length;

q_pat_offset, s_pat_offset, q_pat_length,

q_pat_offset, s_pat_offset,

*hsp_list_ptr = hsp_list;

q_pat_length,

s_pat_length,

score_right, score_left, private_q_length, private_s_length;

(!gap_align || !score_params || !pattern_blk)

&private_q_length, &private_s_length,

, rev_prelim_tback,

gap_align->

= q_start - private_q_length;

s_pat_length, pat_prelim_tback, score_params->

,

gap_align->

->

, pattern_blk);

q_start += q_pat_length - 1;

s_start += s_pat_length - 1;

((q_start < query_length) && (s_start < subject_length)) {

query_length-q_start-1, subject_length-s_start-1,

&private_q_length, &private_s_length,

, fwd_prelim_tback,

gap_align->

= q_start + private_q_length + 1;

gap_align->

= s_start + private_s_length + 1;

(found_end ==

) {

gap_align->

= score_right + score_left;

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

Int4 Blast_SemiGappedAlign(const Uint1 *A, const Uint1 *B, Int4 M, Int4 N, Int4 *a_offset, Int4 *b_offset, Boolean score_only, GapPrelimEditBlock *edit_block, BlastGapAlignStruct *gap_align, const BlastScoringParameters *score_params, Int4 query_offset, Boolean reversed, Boolean reverse_sequence, Boolean *fence_hit)

Low level function to perform gapped extension in one direction with or without traceback.

GapEditScript * Blast_PrelimEditBlockToGapEditScript(GapPrelimEditBlock *rev_prelim_tback, GapPrelimEditBlock *fwd_prelim_tback)

Convert the initial list of traceback actions from a non-OOF gapped alignment into a blast edit scrip...

Structures and functions prototypes used for BLAST gapped extension.

Private interface for blast_gapalign.c.

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.

Int2 Blast_HSPListSaveHSP(BlastHSPList *hsp_list, BlastHSP *hsp)

Saves HSP information into a BlastHSPList structure.

void Blast_HSPListSortByScore(BlastHSPList *hsp_list)

Sort the HSPs in an HSP list by score.

EBlastProgramType

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

ncbi::TMaskedQueryRegions mask

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

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

GapPrelimEditBlock * GapPrelimEditBlockFree(GapPrelimEditBlock *edit_block)

Frees a preliminary edit block structure.

@ eGapAlignIns

Insertion: a gap in subject.

@ eGapAlignSub

Substitution.

@ eGapAlignDel

Deletion: a gap in query.

void GapPrelimEditBlockAppend(GapPrelimEditBlock *edit_block1, GapPrelimEditBlock *edit_block2)

Append one GapPrelimEditBlock to the end of the other.

GapPrelimEditBlock * GapPrelimEditBlockNew(void)

Allocates a preliminary edit block structure.

void GapPrelimEditBlockReset(GapPrelimEditBlock *edit_block)

Reset a preliminary edit block without freeing it.

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

int8_t Int1

1-byte (8-bit) signed integer

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

Smallest (most negative) number represented by signed int.

#define MAX(a, b)

returns larger of a and b.

Int4 _PHIBlastFindHitsShort(Int4 *hitArray, const Uint1 *seq, Int4 len1, const SPHIPatternSearchBlk *pattern_blk)

Routine to find hits of pattern to sequence when sequence is proteins.

void _PHIPatternWordsLeftShift(Int4 *a, Uint1 b, Int4 numWords)

Shift each word in the array left by 1 bit and add bit b.

Int4 _PHIPatternWordsBitwiseAnd(Int4 *result, Int4 *a, Int4 *b, Int4 numWords)

Do a word-by-word bit-wise and of two integer arrays and put the result in a new array.

void _PHIGetRightOneBits(Int4 s, Int4 mask, Int4 *rightOne, Int4 *rightMaskOnly)

Looks for 1 bits in the same position of s and mask Let R be the rightmost position where s and mask ...

void _PHIPatternWordsBitwiseOr(Int4 *a, Int4 *b, Int4 numWords)

Do a word-by-word bit-wise or of two integer arrays and put the result back in the first array.

@ eMultiWord

Does pattern consist of a multiple words?

@ eOneWord

Does pattern consist of a single word?

#define PHI_BITS_PACKED_PER_WORD

Number of bits packed in a word.

#define PHI_MAX_HIT

Maximal size of an array of pattern hits.

Auxiliary functions for finding pattern matches in sequence (PHI-BLAST), that are used in multiple so...

const int kMaskAaAlphabetBits

Masks all bits corresponding to the aminoacid alphabet, i.e.

#define MAX_HITS_IN_WORD

Maximal possible size of the hits array for one word of pattern.

static Int4 s_Align(Uint1 *seq1, Uint1 *seq2, Int4 end1, Int4 end2, Int4 lowDiag, Int4 highDiag, Int4 **matrix, Int4 gapOpen, Int4 gapExtend, GapPrelimEditBlock *alignScript)

Returns the cost of an optimum conversion within highDiag and lowDiag between two sequence segments a...

static Int4 s_BandedAlign(Uint1 *seq1, Uint1 *seq2, Int4 start1, Int4 start2, Int4 lowDiag, Int4 highDiag, Int4 **matrix, Int4 gapOpen, Int4 gapExtend, GapPrelimEditBlock *alignScript)

Do a banded gapped alignment of two sequences.

Int2 PHIGappedAlignmentWithTraceback(Uint1 *query, Uint1 *subject, BlastGapAlignStruct *gap_align, const BlastScoringParameters *score_params, Int4 q_start, Int4 s_start, Int4 query_length, Int4 subject_length, Int4 q_pat_length, Int4 s_pat_length, SPHIPatternSearchBlk *pattern_blk)

Perform a gapped alignment with traceback for PHI BLAST.

static Int4 s_PHIBlastAlignPatterns(Uint1 *querySeq, Uint1 *dbSeq, Int4 lenQuerySeq, Int4 lenDbSeq, GapPrelimEditBlock *alignScript, const BlastScoringOptions *score_options, SBlastScoreMatrix *score_matrix, SPHIPatternSearchBlk *pattern_blk)

Align pattern occurrences of the query and subject sequences.

static Int2 s_PHIGetShortPattern(Uint1 *seq, Int4 len, Int4 *start, Int4 *end, SPHIPatternSearchBlk *pattern_blk)

Finds the position of the first pattern match in an input sequence, if pattern consists of a single w...

static Int2 s_PHIGetExtraLongPattern(Uint1 *seq, Int4 len, Int4 *hitArray, SPHIPatternSearchBlk *pattern_blk)

Find pattern occurrences in seq when the pattern description is extra long, report the results back i...

static Int4 s_GapCost(Int4 gap_open, Int4 gap_extend, Int4 length)

k-symbol indel cost.

static void s_PHIGetLongPattern(Uint1 *seq, Int4 len, Int4 *start, Int4 *end, SPHIPatternSearchBlk *pattern_blk)

Finds the position of the first pattern match in an input sequence, if pattern consists of a more tha...

static Int2 s_PHIGappedAlignment(BLAST_SequenceBlk *query_blk, BLAST_SequenceBlk *subject_blk, BlastGapAlignStruct *gap_align, const BlastScoringParameters *score_params, Int4 query_offset, Int4 subject_offset, Int4 query_length, Int4 subject_length)

Performs gapped extension for PHI BLAST, given two sequence blocks, scoring and extension options,...

Int2 PHIGetGappedScore(EBlastProgramType program_number, BLAST_SequenceBlk *query, BlastQueryInfo *query_info, BLAST_SequenceBlk *subject, BlastGapAlignStruct *gap_align, const BlastScoringParameters *score_params, const BlastExtensionParameters *ext_params, const BlastHitSavingParameters *hit_params, const BlastInitialWordParameters *word_params, BlastInitHitList *init_hitlist, BlastHSPList **hsp_list_ptr, BlastGappedStats *gapped_stats, Boolean *fence_hit)

Preliminary gapped alignment for PHI BLAST.

Function prototypes used for PHI BLAST gapped extension and gapped extension with traceback.

Structure to hold a sequence.

Int4 length

Length of sequence.

Uint1 * sequence

Sequence used for search (could be translation).

Int1 frame

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

Computed values used as parameters for gapped alignments.

Structure supporting the gapped alignment.

GapPrelimEditBlock * fwd_prelim_tback

traceback from right extensions

GapPrelimEditBlock * rev_prelim_tback

traceback from left extensions

Int4 query_stop

query end offseet of current alignment

Int4 subject_start

subject start offset current alignment

BlastScoreBlk * sbp

Pointer to the scoring information block.

Int4 query_start

query start offset of current alignment

Int4 subject_stop

subject end offset of current alignment

Int4 score

Return value: alignment score.

GapEditScript * edit_script

The traceback (gap) information.

Auxiliary structure for dynamic programming gapped extension.

Int4 best_gap

score of best path that ends in a gap at this position

Int4 best

score of best path that ends in a match at this position

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.

Structure holding all information about an HSP.

SPHIHspInfo * pat_info

In PHI BLAST, information about this pattern match.

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

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

Int4 cutoff_score_min

smallest cutoff score across all contexts

BlastHitSavingOptions * options

The original (unparsed) options.

Structure to hold the initial HSP 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.

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

The query related information.

BlastContextInfo * contexts

Information per context.

struct SPHIQueryInfo * pattern_info

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

SBlastScoreMatrix * matrix

scoring matrix data

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

Int4 gap_open

Extra penalty for starting a gap.

Int4 gap_extend

Penalty for each gap residue.

Boolean gapped_calculation

gap-free search if FALSE

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

BlastScoringOptions * options

User-provided values for these params.

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

Scoring matrix used in BLAST.

int ** data

actual scoring matrix data, stored in row-major form

Auxiliary items needed for a PHI BLAST search with pattern containing multiple words.

Int4 match_maskL[100]

Bit mask representation of input pattern for long patterns.

SExtraLongPatternItems * extra_long_items

Additional items necessary if pattern contains pieces longer than a word.

Int4 SLL[100][256]

For each letter in the alphabet and each word in the masked pattern representation,...

Int4 inputPatternMasked[(30 *11)]

Masked input pattern.

Int4 bitPatternByLetter[256][11]

Which positions can a character occur in for long patterns.

Int4 numWords

Number of words need to hold bit representation of pattern.

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

Int4 index

Index of query pattern occurrence for this HSP.

Int4 length

Length of this pattern occurrence in subject.

Information about a single pattern occurence in the query.

Int4 length

Length of this pattern occurrence.

Int4 offset

Starting offset of this pattern occurrence.

Structure containing all auxiliary information needed in a pattern search.

SShortPatternItems * one_word_items

Items necessary when pattern fits in one word.

EPatternType flagPatternLength

Indicates if the whole pattern fits in 1 word, each of several parts of the pattern fit in a word,...

SLongPatternItems * multi_word_items

Additional items, when pattern requires multiple words.

Int4 num_patterns

Number of pattern occurrences in query.

SPHIPatternInfo * occurrences

Array of pattern occurrence information structures.

Auxiliary items needed for a PHI BLAST search with a pattern that fits in a single word.

Int4 * whichPositionPtr

Array of positions where pattern lettern should match, for a single word of the pattern.

Int4 match_mask

Bit mask representation of input pattern for patterns that fit in a word.

Uint4 s_start

Start offset of pattern in subject.

Uint4 s_end

End offset of pattern in subject.

struct BlastOffsetPair::@7 phi_offsets

Pattern offsets in subject (PHI BLAST only)

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