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

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

data_type_sz)

** retval =

;

retval = (

**)

(

(

*) * ncols);

(

= 0;

< ncols;

++) {

retval[

] = (

*)

(nrows, data_type_sz);

(

= 0;

< ncols;

++) {

( !msa || !msa->dimensions || !msa->data ) {

(

*) msa->dimensions,

msa->dimensions->query_length,

( !retval->

) {

(s = 0; s < msa->dimensions->num_seqs + 1; s++) {

(p = 0; p < msa->dimensions->query_length; p++) {

retval->

[s][p].

= msa->data[s][p].letter;

(s = 0; s < msa->dimensions->num_seqs + 1; s++) {

retval = 0;

PrintMsa(

* filename,

* msa)

= fopen(filename,

);

PrintMsaFP(

, msa);

PrintMsaFP(FILE*

,

* msa)

fprintf(

,

,

,

msa->seqinfo[

].gi,

msa->seqinfo[

].evalue,

msa->seqinfo[

].bit_score);

fprintf(

,

);

fprintf(

,

,

);

fprintf(

,

);

fprintf(

,

);

__printPackedMsa(

* filename,

* msa)

= fopen(filename,

);

__printPackedMsaFP(

, msa);

( !retval->

) {

( !retval->

) {

retval->

= query_length;

retval->

= alphabet_size;

( !retval->

) {

(pssm_data->

) {

pssm_data->

= (

**)

( !retval->

) {

(

= 0;

< query_length;

++) {

( !aligned_blocks ) {

(aligned_blocks->

) {

(aligned_blocks);

( !retval->

) {

( !seq_weights ) {

(seq_weights->

) {

msa->

[p] == kGapResidue) {

(msa->

[s][p].

== kGapResidue) {

(msa->

[s][p].

== kGapResidue) {

found_aligned_sequence =

;

(msa->

[s][p].

!= kGapResidue) {

found_non_gap_residue =

;

( !found_aligned_sequence ) {

( !found_non_gap_residue ) {

( !ignore_unaligned_positions ) {

(cd_msa->

[p] == kGapResidue) {

(!cd_msa->

[s][p].

) {

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

max_percent_identity);

kQueryLength = 0;

kNumberOfSeqs = 0;

(p = 0; p < kQueryLength; p++) {

(s = 0; s < kNumberOfSeqs; s++) {

(p = 0; p < kQueryLength; p++, pos++) {

fprintf(stderr,

, position,

fprintf(stderr,

, traits->

);

fprintf(stderr,

, traits->

);

fprintf(stderr,

, traits->

);

traits->

= position;

max_percent_identity)

percent_identity =

(percent_identity >= max_percent_identity) {

align_stop =

traits->

, align_stop);

max_percent_identity)

( seq_index1 == seq_index2 ||

seq1 = msa->

[seq_index1];

seq2 = msa->

[seq_index2];

(p = 0; p < kQueryLength; p++, seq1++, seq2++) {

(!kPos1Aligned && !kPos2Aligned) {

max_percent_identity);

seq1->

!= kXResidue && seq2->

!= kXResidue;

(neither_is_X && (kPos2Aligned && seq1->

) &&

max_percent_identity);

( !msa || !aligned_blocks ) {

(seq_index < msa->dimensions->num_seqs + 1);

sequence_position = msa->

[seq_index];

sequence_position[

].

!= kGapResidue) {

( !sequence_position[curr].

) {

(seq_index < msa->dimensions->num_seqs + 1);

sequence_position = msa->

[seq_index];

sequence_position[

].

!= kGapResidue) {

(curr =

- 1; curr >= 0; curr--,

--) {

( !sequence_position[curr].

) {

(seq_index < msa->dimensions->num_seqs + 1);

sequence_position = msa->

[seq_index];

sequence_position[

].

!= kGapResidue) {

kQueryLength = 0;

(

= 0;

< kQueryLength;

++) {

(

= 0;

< kQueryLength;

++) {

(msa->

[

] == kXResidue) {

(idx = 0; idx <

; idx++) {

msa->

[idx] != kXResidue) {

aligned_blocks->

[idx]--;

msa->

[idx] != kXResidue) {

aligned_blocks->

[idx]--;

nsg_compatibility_mode);

nsg_compatibility_mode);

nsg_compatibility_mode,

kQueryLength = 0;

kExpectedNumMatchingSeqs = nsg_compatibility_mode ? 0 : 1;

last_calc_pos = 0;

( !msa || !aligned_blocks || !seq_weights ) {

( !aligned_seqs || !prev_pos_aligned_seqs ) {

(pos = 0; pos < kQueryLength; pos++) {

(aligned_blocks->

[pos] == 0 ||

(aligned_seqs->

<= kExpectedNumMatchingSeqs) {

last_calc_pos = pos;

(last_calc_pos != pos - 1 ||

memset((

*)seq_weights->

, 0,

aligned_seqs, seq_weights);

seq_weights->

[pos] = seq_weights->

[pos-1];

nsg_compatibility_mode);

nsg_compatibility_mode);

(sum_weights);

kQueryLength = 0;

* sum_weights =

;

( !cd_msa || !seq_weights || !sbp || !options) {

( !sum_weights) {

(pos = 0; pos < kQueryLength; pos++) {

total_observations = 0.0;

memset(sum_weights, 0, sbp->

*

(

));

total_observations +=

(residue = 0; residue < sbp->

; residue++) {

sum_weights[residue] +=

(total_observations > 0.0 && query_residue != kXResidue

&& sum_weights[query_residue] == 0.0) {

sum_weights[query_residue] = 1.0;

total_observations += 1.0;

(total_observations > 0.0) {

(residue = 0; residue < sbp->

; residue++) {

sum_weights[residue] / total_observations;

total_observations);

(position < msa->dimensions->query_length);

num_distinct_residues_for_column = 0;

num_local_std_letters = 0;

(i < msa->dimensions->query_length);

(asi = 0; asi < aligned_seqs->

; asi++) {

kSeqIdx = aligned_seqs->

[asi];

(residue_counts_for_column[kResidue] == 0) {

num_distinct_residues_for_column++;

(kResidue != kGapResidue && kResidue != kXResidue)

num_local_std_letters++;

residue_counts_for_column[kResidue]++;

sigma += num_distinct_residues_for_column;

(num_distinct_residues_for_column > 1) {

distinct_residues_found =

;

(asi = 0; asi < aligned_seqs->

; asi++) {

seq_idx = aligned_seqs->

[asi];

(residue_counts_for_column[residue] *

num_distinct_residues_for_column) );

seq_weights->

[position] = sigma;

(distinct_residues_found) {

weight_sum = 0.0;

(asi = 0; asi < aligned_seqs->

; asi++) {

seq_idx = aligned_seqs->

[asi];

(asi = 0; asi < aligned_seqs->

; asi++) {

seq_idx = aligned_seqs->

[asi];

(asi = 0; asi < aligned_seqs->

; asi++) {

seq_idx = aligned_seqs->

[asi];

(1.0/(double) aligned_seqs->

);

(asi = 0; asi < aligned_seqs->

; asi++) {

seq_idx = aligned_seqs->

[asi];

(residue != kGapResidue) {

(position < msa->dimensions->query_length);

msa->

[

][position].

!= kGapResidue) {

nsg_compatibility_mode)

kExpectedNumMatchingSeqs = nsg_compatibility_mode ? 0 : 1;

nsg_compatibility_mode)

kExpectedNumMatchingSeqs = nsg_compatibility_mode ? 0 : 1;

running_total = 0.0;

(residue = 0; residue < msa->

; residue++) {

running_total += seq_weights->

[pos][residue];

(running_total < 0.99 || running_total > 1.01) {

check_performed =

;

( !check_performed &&

!nsg_compatibility_mode ) {

(!

);

columnNumber,

queryLength,

*expno);

*backgroundProbabilities,

observations);

nsg_compatibility_mode,

kZeroObsPseudo = 30.0;

( !msa || !seq_weights || !sbp || !aligned_blocks || !internal_pssm ) {

columnCounts = 0.0;

observations = 0.0;

pseudoWeight;

(0 == pseudo_count)

columnCounts = pseudo_count;

pseudoWeight = kZeroObsPseudo;

pseudoWeight = columnCounts;

pseudo = 0.0;

kBeta = pseudoWeight;

numerator = 0.0;

denominator = 0.0;

qOverPEstimate = 0.0;

freq_ratios->

[

][

]);

denominator = observations + kBeta;

(nsg_compatibility_mode && denominator == 0.0) {

(denominator != 0.0);

qOverPEstimate = numerator/denominator;

internal_pssm->

[p][

] = qOverPEstimate *

kZeroObsPseudo = 30.0;

* backgroundProbabilities =

;

( !cd_msa || !seq_weights || !sbp || !internal_pssm || pseudo_count < 0) {

( !freq_ratios ) {

( !backgroundProbabilities ) {

columnCounts = 0.0;

observations = 0.0;

pseudoWeight;

(cd_msa->

[p] != kXResidue)

observations =

(0.0,

(0 == pseudo_count)

columnCounts = pseudo_count;

pseudoWeight = kZeroObsPseudo;

pseudoWeight = columnCounts;

(cd_msa->

[p] == kXResidue ||

pseudo = 0.0;

kBeta = pseudoWeight;

numerator = 0.0;

denominator = 0.0;

qOverPEstimate = 0.0;

freq_ratios->

[

][

]);

denominator = observations + kBeta;

(denominator != 0.0);

qOverPEstimate = numerator/denominator;

internal_pssm->

[p][

] = qOverPEstimate *

* std_prob,

* retval =

;

( !std_prob || !score_mat ) {

retval = (

*)

(query_length,

(

));

(p = 0; p < query_length; p++) {

info_sum = 0.0;

(

= 0;

< alphabet_sz;

++) {

exponent = exp(score *

);

= std_prob[

] * exponent;

retval[p] = info_sum;

** freq_ratios,

* std_prob,

* retval =

;

( !std_prob || !freq_ratios ) {

retval = (

*)

(query_length,

(

));

(p = 0; p < query_length; p++) {

info_sum = 0.0;

(

= 0;

< alphabet_sz;

++) {

qOverPEstimate = freq_ratios[p][

] / std_prob[

];

retval[p] = info_sum;

* std_probs)

ideal_lambda = 0.0;

( !internal_pssm || !sbp || !std_probs )

(

= 0;

< internal_pssm->

;

++) {

qOverPEstimate = 0.0;

(is_unaligned_column && qOverPEstimate != 0.0) {

is_unaligned_column =

;

(qOverPEstimate == 0.0 || std_probs[j] <

) {

=

(qOverPEstimate)/ideal_lambda;

( (j == kXResidue || j == kStarResidue) &&

(is_unaligned_column) {

(freq_ratios->

[kResidue][j] != 0.0) {

* std_probs,

** scaled_pssm =

;

** pssm =

;

factor_low = 1.0;

factor_high = 1.0;

ideal_lambda = 0.0;

new_lambda = 0.0;

query_length = 0;

( !internal_pssm || !sbp || !

|| !std_probs )

pssm = internal_pssm->

;

query_length = internal_pssm->

;

(

= 0;

< internal_pssm->

;

++) {

(j = 0; j < internal_pssm->

; j++) {

(new_lambda > ideal_lambda) {

factor = factor_high;

first_time =

;

(too_high ==

) {

factor_high += (factor_high - 1.0);

factor = factor_high;

}

(new_lambda > 0) {

factor = factor_low;

first_time =

;

(too_high ==

) {

factor_low += (factor_low - 1.0);

factor = factor_low;

factor = (factor_high + factor_low)/2;

(

= 0;

< internal_pssm->

;

++) {

(j = 0; j < internal_pssm->

; j++) {

(new_lambda > ideal_lambda) {

factor_low = factor;

factor_high = factor;

scaling_factor)

scaling_factor,

, sbp);

internal_pssm->

, internal_pssm->

);

(

= 0;

< length;

++) {

(seq[

] != kXResidue) {

* std_probs,

alphabet_size = 0;

effective_length = 0;

(alphabet_size <= 0) {

(p = 0; p < query_length; p++) {

(

[p] == kXResidue) {

(

= 0;

< alphabet_size;

++) {

= pssm[p][aa_alphabet[

]];

( !score_freqs ) {

score_freqs->

= min_score;

score_freqs->

= max_score;

(p = 0; p < query_length; p++) {

(

[p] == kXResidue) {

(

= 0;

< alphabet_size;

++) {

= pssm[p][aa_alphabet[

]];

(std_probs[aa_alphabet[

]]/effective_length);

(s = min_score; s <= max_score; s++) {

* std_probs,

contains_aligned_regions =

;

( !contains_aligned_regions ) {

seq_index,

sequence_position = msa->

[seq_index];

(

= start;

< stop;

++) {

sequence_position[

].

= 0;

( !diagnostics || !msa || !aligned_block || !seq_weights ||

!internal_pssm || !internal_pssm->

) {

(seq_weights->

[p] / aligned_block->

[p] - 1);

(diagnostics->

) {

diagnostics->

[p] = seq_weights->

[p];

( !diagnostics || !cd_msa || !seq_weights ||

!internal_pssm || !internal_pssm->

) {

probabilities[c] = posSearch->

[columnNumber][charOrder[c]];

*probabilitiesToReturn,

standardWeight,

*standardProbabilities,

observations)

intermediateSums[c] =

(initialProbabilities[c] * observations) +

(standardProbabilities[c] * standardWeight);

overallSum += intermediateSums[c];

probabilitiesToReturn[c] = intermediateSums[c]/overallSum;

*backgroundProbabilities)

returnValue += (newDistribution[c] *

(newDistribution[c]/backgroundProbabilities[c]));

(returnValue);

*backgroundProbabilities)

weighted_sum;

weighted_sum += exp(j*

(1.0-backgroundProbabilities[k]));

*backgroundProbabilities,

observations)

relativeEntropy;

pseudoDenominator;

kPseudoMult = 500.0;

kPseudoNumerator = 0.0457;

kPseudoExponent = 0.8;

kPseudoSmallInitial = 5.5;

&(columnProbabilitiesAdjusted[0]),

kPseudoSmallInitial,

backgroundProbabilities, observations);

backgroundProbabilities);

pseudoDenominator = pow(relativeEntropy, kPseudoExponent);

alpha = kPseudoNumerator/pseudoDenominator;

returnValue = kPseudoMult * alpha/ (1- alpha);

(returnValue);

columnNumber,

queryLength,

*expno)

totalDistinctCounts;

aveDistinctAA;

columnsAccountedFor;

columnsAccountedFor = 0;

totalDistinctCounts = 0;

(columnsAccountedFor < halfNumColumns) {

(columnsAccountedFor > halfNumColumns) {

totalDistinctCounts -=

((columnsAccountedFor - halfNumColumns) * k);

columnsAccountedFor = halfNumColumns;

aveDistinctAA = ((double) totalDistinctCounts)/

((double) columnsAccountedFor);

-(expno[

]-aveDistinctAA)/(expno[

]-expno[

-1]);

indep =

(0,indep - 1);

#define sfree(x)

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

Int2 DynamicUint4Array_Append(SDynamicUint4Array *arr, Uint4 element)

Append a Uint4 to the dynamic array structure.

SDynamicUint4Array * DynamicUint4Array_Dup(const SDynamicUint4Array *src)

Make a deep copy of the src dynamic array.

Int4 DynamicUint4Array_Copy(SDynamicUint4Array *dest, const SDynamicUint4Array *src)

Make a shallow copy of the src dynamic array into the dest dynamic array.

SDynamicUint4Array * DynamicUint4ArrayNewEx(Uint4 init_num_elements)

Allocate a dynamic array of Uint4 with an initial size of specified as an argument to the function.

Boolean DynamicUint4Array_AreEqual(const SDynamicUint4Array *a, const SDynamicUint4Array *b)

Compares dynamic arrays a and b for equality of its contents.

SDynamicUint4Array * DynamicUint4ArrayFree(SDynamicUint4Array *arr)

Deallocates a dynamic array structure.

Declarations for various dynamic array types.

int Kappa_impalaScaling(Kappa_posSearchItems *posSearch, Kappa_compactSearchItems *compactSearch, double scalingFactor, Boolean doBinarySearch, BlastScoreBlk *sbp)

Copied from posit2.c.

Kappa_compactSearchItems * Kappa_compactSearchItemsNew(const Uint1 *query, unsigned int queryLength, BlastScoreBlk *sbp)

Creates a new Kappa_compactSearchItems structure.

Kappa_posSearchItems * Kappa_posSearchItemsFree(Kappa_posSearchItems *posSearch)

Deallocates the Kappa_posSearchItems structure.

Kappa_compactSearchItems * Kappa_compactSearchItemsFree(Kappa_compactSearchItems *compactSearch)

Deallocates the Kappa_compactSearchItems structure.

Kappa_posSearchItems * Kappa_posSearchItemsNew(unsigned int queryLength, const char *matrix_name, int **posPrivateMatrix, double **posFreqs)

Allocates a new Kappa_posSearchItems structure.

Port of posit.h structures and impalaScaling for implementing composition based statistics for PSI-BL...

static int s_PSIValidateAlignedColumns(const _PSIMsa *msa)

Validate that there are no unaligned columns or columns which only contain gaps in the multiple seque...

static NCBI_INLINE void _handleEitherAlignedNeitherX(_PSIAlignmentTraits *traits, _EPSIPurgeFsmState *state, Uint4 position)

Handle the event when either position is aligned and neither is X.

static NCBI_INLINE void _handleEitherAlignedEitherX(_PSIAlignmentTraits *traits, _EPSIPurgeFsmState *state)

Handle the event when either position is aligned and either is X.

static NCBI_INLINE void _handleNeitherAligned(_PSIAlignmentTraits *traits, _EPSIPurgeFsmState *state, _PSIPackedMsa *msa, Uint4 seq_index, double max_percent_identity)

Handles neither is aligned event FIXME: document better.

int _PSIComputeAlignmentBlocks(const _PSIMsa *msa, _PSIAlignedBlock *aligned_blocks)

Main function to compute aligned blocks' properties for each position within multiple alignment (stag...

static void _PSIGetLeftExtents(const _PSIMsa *msa, Uint4 seq_index)

Computes the left extents for the sequence identified by seq_index.

int _PSIConvertFreqRatiosToPSSM(_PSIInternalPssmData *internal_pssm, const Uint1 *query, const BlastScoreBlk *sbp, const double *std_probs)

Converts the PSSM's frequency ratios obtained in the previous stage to a PSSM of scores.

static void _PSICalculateMatchWeights(const _PSIMsa *msa, Uint4 position, const SDynamicUint4Array *aligned_seqs, _PSISequenceWeights *seq_weights)

Calculate the weighted observed sequence weights.

int _PSIComputeFreqRatios(const _PSIMsa *msa, const _PSISequenceWeights *seq_weights, const BlastScoreBlk *sbp, const _PSIAlignedBlock *aligned_blocks, Int4 pseudo_count, Boolean nsg_compatibility_mode, _PSIInternalPssmData *internal_pssm)

Main function to compute the PSSM's frequency ratios (stage 5).

void ** _PSIAllocateMatrix(unsigned int ncols, unsigned int nrows, unsigned int data_type_sz)

Generic 2 dimensional matrix allocator.

static int s_PSIValidateNoGapsInQuery(const _PSIMsa *msa)

Validate that there are no gaps in the query sequence.

void _PSIStructureGroupCustomization(_PSIMsa *msa)

Enable NCBI structure group customization to discard the query sequence, as this really isn't the res...

int _PSIComputeFreqRatiosFromCDs(const PSICdMsa *cd_msa, const _PSISequenceWeights *seq_weights, const BlastScoreBlk *sbp, Int4 pseudo_count, _PSIInternalPssmData *internal_pssm)

Main function to compute CD-based PSSM's frequency ratios.

_PSISequenceWeights * _PSISequenceWeightsNew(const PSIMsaDimensions *dimensions, const BlastScoreBlk *sbp)

Allocates and initializes the _PSISequenceWeights structure.

static void _PSISpreadGapWeights(const _PSIMsa *msa, _PSISequenceWeights *seq_weights, Boolean nsg_compatibility_mode)

Uses disperse method of spreading the gap weights.

_PSIInternalPssmData * _PSIInternalPssmDataNew(Uint4 query_length, Uint4 alphabet_size)

Allocates a new _PSIInternalPssmData structure.

static void _PSIGetAlignedSequencesForPosition(const _PSIMsa *msa, Uint4 position, SDynamicUint4Array *aligned_sequences)

Populates the array aligned_sequences with the indices of the sequences which are part of the multipl...

_PSIAlignedBlock * _PSIAlignedBlockNew(Uint4 query_length)

Allocates and initializes the _PSIAlignedBlock structure.

unsigned int _PSIPackedMsaGetNumberOfAlignedSeqs(const _PSIPackedMsa *msa)

Retrieve the number of aligned sequences in the compact multiple sequence alignment.

int _PSIComputeSequenceWeights(const _PSIMsa *msa, const _PSIAlignedBlock *aligned_blocks, Boolean nsg_compatibility_mode, _PSISequenceWeights *seq_weights)

Main function to calculate the sequence weights.

int _PSISaveDiagnostics(const _PSIMsa *msa, const _PSIAlignedBlock *aligned_block, const _PSISequenceWeights *seq_weights, const _PSIInternalPssmData *internal_pssm, PSIDiagnosticsResponse *diagnostics)

Collects diagnostic information from the process of creating the PSSM.

static int s_PSIValidateParticipatingSequences(const _PSIMsa *msa)

Verify that after purging biased sequences in multiple sequence alignment there are still sequences p...

static void s_fillColumnProbabilities(double *probabilities, const _PSISequenceWeights *posSearch, Int4 columnNumber)

Reorders in the same manner as returned by Blast_GetMatrixBackgroundFreq this function is a copy of p...

double * _PSICalculateInformationContentFromScoreMatrix(Int4 **score_mat, const double *std_prob, const Uint1 *query, Uint4 query_length, Uint4 alphabet_sz, double lambda)

Calculates the information content from the scoring matrix.

static int _PSICheckSequenceWeights(const _PSIMsa *msa, const _PSISequenceWeights *seq_weights, Boolean nsg_compatibility_mode)

Verifies that the sequence weights for each column of the PSSM add up to 1.0.

const double kPosEpsilon

minimum return value of s_computeRelativeEntropy

Blast_ScoreFreq * _PSIComputeScoreProbabilities(const int **pssm, const Uint1 *query, Uint4 query_length, const double *std_probs, const BlastScoreBlk *sbp)

Compute the probabilities for each score in the PSSM.

static double s_effectiveObservations(const _PSIAlignedBlock *align_blk, const _PSISequenceWeights *seq_weights, int columnNumber, int queryLength, const double *expno)

A method to estimate the effetive number of observations in the interval for the specified columnNumb...

static double s_columnSpecificPseudocounts(const _PSISequenceWeights *posSearch, int columnNumber, const double *backgroundProbabilities, const double observations)

copy of posit.c:columnSpecificPseudocounts

int _PSIPurgeBiasedSegments(_PSIPackedMsa *msa)

Main function for keeping only those selected sequences for PSSM construction (stage 2).

static void s_PSIDiscardIfUnused(_PSIPackedMsa *msa, unsigned int seq_index)

Check if we still need this sequence.

int _PSIComputeFrequenciesFromCDs(const PSICdMsa *cd_msa, BlastScoreBlk *sbp, const PSIBlastOptions *options, _PSISequenceWeights *seq_weights)

Main function to calculate CD weights and combine weighted residue counts from matched CDs.

static int s_PSIValidateNoFlankingGaps(const _PSIMsa *msa)

Validate that there are no flanking gaps in the multiple sequence alignment.

static void s_initializeExpNumObservations(double *expno, const double *backgroundProbabilities)

initialize the expected number of observations use background probabilities for this matrix Calculate...

_PSIMsa * _PSIMsaNew(const _PSIPackedMsa *msa, Uint4 alphabet_size)

Allocates and initializes the internal version of the PSIMsa structure (makes a deep copy) for intern...

_EPSIPurgeFsmState

Defines the states of the finite state machine used in s_PSIPurgeSimilarAlignments.

static void _PSIComputeAlignedRegionLengths(const _PSIMsa *msa, _PSIAlignedBlock *aligned_blocks)

Calculates the aligned blocks lengths in the multiple sequence alignment data structure.

const int kPSIScaleFactor

Successor to POSIT_SCALE_FACTOR.

const double kPSINearIdentical

Percent identity threshold for discarding near-identical matches.

const Uint4 kPositScalingNumIterations

Constant used in scaling PSSM routines: Successor to POSIT_NUM_ITERATIONS.

_PSISequenceWeights * _PSISequenceWeightsFree(_PSISequenceWeights *seq_weights)

Deallocates the _PSISequenceWeights structure.

void ** _PSIDeallocateMatrix(void **matrix, unsigned int ncols)

Generic 2 dimensional matrix deallocator.

void _PSICopyMatrix_int(int **dest, int **src, unsigned int ncols, unsigned int nrows)

Copies src matrix into dest matrix, both of which must be int matrices with dimensions ncols by nrows...

#define MAX_IND_OBSERVATIONS

max number of independent observation for pseudocount calculation

static void s_PSIComputeFrequenciesFromCDsCleanup(double *sum_weights)

static NCBI_INLINE void _handleBothAlignedSameResidueNoX(_PSIAlignmentTraits *traits, _EPSIPurgeFsmState *state)

Handle event when both positions are aligned, using the same residue, but this residue is not X.

Uint4 _PSISequenceLengthWithoutX(const Uint1 *seq, Uint4 length)

Calculates the length of the sequence without including any 'X' residues.

static void s_PSIPurgeSimilarAlignments(_PSIPackedMsa *msa, Uint4 seq_index1, Uint4 seq_index2, double max_percent_identity)

This function compares the sequences in the msa->cell structure indexed by sequence_index1 and seq_in...

static void _PSIGetRightExtents(const _PSIMsa *msa, Uint4 seq_index)

Computes the right extents for the sequence identified by seq_index.

void _PSIUpdateLambdaK(const int **pssm, const Uint1 *query, Uint4 query_length, const double *std_probs, BlastScoreBlk *sbp)

Updates the Karlin-Altschul parameters based on the query sequence and PSSM's score frequencies.

static void _PSIComputePositionExtents(const _PSIMsa *msa, Uint4 seq_index, _PSIAlignedBlock *aligned_blocks)

Computes the aligned blocks extents' for each position for the sequence identified by seq_index.

#define PSEUDO_MAX

effective infinity

static double s_computeRelativeEntropy(const double *newDistribution, const double *backgroundProbabilities)

compute relative entropy of first distribution to second distribution A copy of posit....

static void _PSICalculateNormalizedSequenceWeights(const _PSIMsa *msa, const _PSIAlignedBlock *aligned_blocks, Uint4 position, const SDynamicUint4Array *aligned_seqs, _PSISequenceWeights *seq_weights)

Calculates the position based weights using a modified version of the Henikoff's algorithm presented ...

const unsigned int kQueryIndex

Index into multiple sequence alignment structure for the query sequence.

_PSIInternalPssmData * _PSIInternalPssmDataFree(_PSIInternalPssmData *pssm_data)

Deallocates the _PSIInternalPssmData structure.

int _PSIValidateMSA_StructureGroup(const _PSIMsa *msa)

Structure group validation function for multiple sequence alignment structure.

int _PSIScaleMatrix(const Uint1 *query, const double *std_probs, _PSIInternalPssmData *internal_pssm, BlastScoreBlk *sbp)

Scales the PSSM (stage 7)

int _PSIPurgeAlignedRegion(_PSIPackedMsa *msa, unsigned int seq_index, unsigned int start, unsigned int stop)

Marks the (start, stop] region corresponding to sequence seq_index in alignment so that it is not fur...

_PSIMsa * _PSIMsaFree(_PSIMsa *msa)

Deallocates the _PSIMsa data structure.

#define DEFINE_COPY_MATRIX_FUNCTION(type)

Implements the generic copy matrix functions.

_PSIAlignedBlock * _PSIAlignedBlockFree(_PSIAlignedBlock *aligned_blocks)

Deallocates the _PSIAlignedBlock structure.

const double kEpsilon

Small constant to test against 0.

double * _PSICalculateInformationContentFromFreqRatios(double **freq_ratios, const double *std_prob, Uint4 query_length, Uint4 alphabet_sz)

Calculates the information content from the residue frequencies calculated in stage 5 of the PSSM cre...

static void s_PSIPurgeSelfHits(_PSIPackedMsa *msa)

Remove those sequences which are identical to the query sequence.

#define EFFECTIVE_ALPHABET

size of alphabet used for pseudocounts calculations

int _PSISaveCDDiagnostics(const PSICdMsa *cd_msa, const _PSISequenceWeights *seq_weights, const _PSIInternalPssmData *internal_pssm, PSIDiagnosticsResponse *diagnostics)

Collects diagnostic information from the process of creating the CDD-based PSSM.

static void s_PSIPurgeNearIdenticalAlignments(_PSIPackedMsa *msa)

Keeps only one copy of any aligned sequences which are >kPSINearIdentical% identical to one another.

struct _PSIAlignmentTraits _PSIAlignmentTraits

Auxiliary structure to maintain information about two aligned regions between the query and a subject...

int _PSIValidateCdMSA(const PSICdMsa *cd_msa, Uint4 alphabet_size)

Validation of multiple alignment of conserved domains structure.

void _PSIUpdatePositionCounts(_PSIMsa *msa)

Counts the number of sequences matching the query per query position (columns of the multiple alignme...

const double kPSIIdentical

Percent identity threshold for discarding identical matches.

_PSIPackedMsa * _PSIPackedMsaNew(const PSIMsa *msa)

Allocates and initializes the compact version of the PSIMsa structure (makes a deep copy) for interna...

static void s_adjustColumnProbabilities(double *initialProbabilities, double *probabilitiesToReturn, double standardWeight, const double *standardProbabilities, double observations)

adjust the probabilities by assigning observations weight to initialProbabilities and standardWeight ...

const double kPositScalingPercent

Constant used in scaling PSSM routines: Successor to POSIT_PERCENT.

int _IMPALAScaleMatrix(const Uint1 *query, const double *std_probs, _PSIInternalPssmData *internal_pssm, BlastScoreBlk *sbp, double scaling_factor)

Provides a similar function to _PSIScaleMatrix but it performs the scaling as IMPALA did,...

static NCBI_INLINE void _PSIResetAlignmentTraits(_PSIAlignmentTraits *traits, Uint4 position)

Resets the traits structure to restart finite state machine.

_PSIPackedMsa * _PSIPackedMsaFree(_PSIPackedMsa *msa)

Deallocates the _PSIMsa data structure.

int _PSIValidateMSA(const _PSIMsa *msa, Boolean ignore_unaligned_positions)

Main validation function for multiple sequence alignment structure.

Private interface for Position Iterated BLAST API, contains the PSSM generation engine.

#define PSIERR_BADPARAM

Bad parameter used in function.

#define PSIERR_ENDINGGAP

Found flanking gap at end of alignment.

#define PSIERR_UNKNOWN

Unknown error.

#define PSIERR_COLUMNOFGAPS

Found an entire column full of GAP residues.

#define PSIERR_OUTOFMEM

Out of memory.

#define PSIERR_BADPROFILE

Errors in conserved domain profile.

#define PSIERR_POSITIVEAVGSCORE

Positive average score found when scaling matrix.

#define PSIERR_NOALIGNEDSEQS

After purge stage of PSSM creation, no sequences are left.

#define PSIERR_STARTINGGAP

Found flanking gap at start of alignment.

#define PSIERR_BADSEQWEIGHTS

Sequence weights do not add to 1.

#define PSI_SUCCESS

Successful operation.

#define PSIERR_UNALIGNEDCOLUMN

Found an entire column with no participating sequences.

#define PSIERR_GAPINQUERY

GAP residue found in query sequence.

#define BLAST_SCORE_MIN

minimum allowed score (for one letter comparison).

Int2 Blast_GetStdAlphabet(Uint1 alphabet_code, Uint1 *residues, Uint4 residue_size)

Fills a buffer with the 'standard' alphabet (given by STD_AMINO_ACID_FREQS[index]....

Int2 Blast_KarlinBlkUngappedCalc(Blast_KarlinBlk *kbp, Blast_ScoreFreq *sfp)

Computes the parameters lambda, H K for use in calculating the statistical significance of high-scori...

Blast_ScoreFreq * Blast_ScoreFreqFree(Blast_ScoreFreq *sfp)

Deallocates the score frequencies structure.

#define BLAST_SCORE_MAX

maximum allowed score (for one letter comparison).

Blast_ScoreFreq * Blast_ScoreFreqNew(Int4 score_min, Int4 score_max)

Creates a new structure to keep track of score frequencies for a scoring system.

Various auxiliary BLAST utility functions.

#define IS_residue(x)

Does character encode a residue?

double * BLAST_GetStandardAaProbabilities(void)

Get the standard amino acid probabilities.

Constants used in compositional score matrix adjustment.

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

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

#define BLASTAA_SIZE

Size of aminoacid alphabet.

#define BLASTAA_SEQ_CODE

== Seq_code_ncbistdaa

const Uint1 AMINOACID_TO_NCBISTDAA[]

Translates between ncbieaa and ncbistdaa.

const char NCBISTDAA_TO_AMINOACID[]

Translates between ncbieaa and ncbistdaa.

uint8_t Uint1

1-byte (8-bit) unsigned integer

int32_t Int4

4-byte (32-bit) signed integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

unsigned int

A callback function used to compare two keys in a database.

static const char * GetResidue(TokenStatBlkPtr stoken)

SFreqRatios * _PSIMatrixFrequencyRatiosFree(SFreqRatios *freq_ratios)

Deallocate the frequency ratios structure.

SFreqRatios * _PSIMatrixFrequencyRatiosNew(const char *matrix_name)

Retrive the matrix's frequency ratios.

Definitions used to get joint probabilities for a scoring matrix.

const double * Blast_GetMatrixBackgroundFreq(const char *matrix_name)

Return true if frequency data is available for the given matrix name.

bool is_aligned(T *p) noexcept

Check pointer alignment.

Prototypes for portable math library (ported from C Toolkit)

#define NCBIMATH_LN2

Natural log(2)

long BLAST_Nint(double x)

Nearest integer.

#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 MAX(a, b)

returns larger of a and b.

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

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

static const char * kScore

Structure used for scoring calculations.

Blast_KarlinBlk ** kbp_psi

K-A parameters for position-based alignments.

char * name

name of scoring matrix.

Int2 alphabet_size

size of alphabet.

Uint1 alphabet_code

NCBI alphabet code.

SBlastScoreMatrix * matrix

scoring matrix data

Blast_KarlinBlk * kbp_ideal

Ideal values (for query with average database composition).

Blast_KarlinBlk ** kbp_gap_std

K-A parameters for std (not position-based) alignments.

Blast_KarlinBlk ** kbp_gap_psi

K-A parameters for psi alignments.

double K

K value used in statistics.

double Lambda

Lambda value used in statistics.

double logK

natural log of K value used in statistics

Holds score frequencies used in calculation of Karlin-Altschul parameters for an ungapped search.

double score_avg

average score, must be negative for local alignment.

Int4 obs_min

lowest observed (actual) scores

double * sprob

arrays for frequency of given score, shifted down by score_min.

Int4 obs_max

highest observed (actual) scores

Structure used to pass data into the scaling routines.

Structure used to pass data into the scaling routines.

Options used in protein BLAST only (PSI, PHI, RPS and translated BLAST) Some of these possibly should...

double iobsr

Effective number of independent observations in a CD column.

double * wfreqs

Frequencies for each residue in CD column.

Uint1 is_aligned

Does this cell represent column aligned to a CD.

PSICdMsaCellData * data

Data needed for PSSM computation.

Data structure representing multiple alignemnt of CDs and query sequence along with data needed for P...

PSIMsaDimensions * dimensions

Query length and number of aligned cds.

unsigned char * query

Query sequence as Ncbistdaa.

PSICdMsaCell ** msa

Multiple alignment of CDs.

This structure contains the diagnostics information requested using the PSIDiagnosticsRequest structu...

double * information_content

position information content (query_length elements)

Uint4 ** residue_freqs

observed residue frequencies per position of the PSSM (Dimensions are query_length by alphabet_size)

double ** weighted_residue_freqs

Weighted observed residue frequencies per position of the PSSM.

Uint4 * interval_sizes

interval sizes of aligned regions (query_length elements)

Uint4 alphabet_size

Specifies length of alphabet.

Uint4 query_length

Specifies the number of positions in the PSSM.

double * gapless_column_weights

Weights for columns without gaps (query_length elements)

double * independent_observations

Effective number of observations per column.

Uint4 * num_matching_seqs

number of matching sequences per query position (query_length elements)

double * sigma

sigma (query_length elements)

double ** frequency_ratios

PSSM's frequency ratios (Dimensions are query_length by alphabet_size)

Boolean is_aligned

Is this letter part of the alignment?

Uint1 letter

Preferred letter at this position, in ncbistdaa encoding.

Structure representing the dimensions of the multiple sequence alignment data structure.

Uint4 num_seqs

Number of distinct sequences aligned with the query (does not include the query)

Uint4 query_length

Length of the query.

Multiple sequence alignment (msa) data structure containing the raw data needed by the PSSM engine to...

PSIMsaCell ** data

actual data, dimensions are (dimensions->num_seqs+1) by (dimensions->query_length)

PSIMsaDimensions * dimensions

dimensions of the msa

int ** data

actual scoring matrix data, stored in row-major form

Data structure to maintain a dynamically allocated array of Uint4.

Uint4 * data

array of Uint4

Uint4 num_used

number of elements used in this array

Uint4 num_allocated

size of array below

Stores the frequency ratios along with their bit scale factor.

double ** data

The actual frequency ratios.

int bit_scale_factor

Used to multiply the values in the above matrix to obtain scores in bit units.

A structure containing two integers, used e.g.

Int4 left

left endpoint of range (zero based)

Int4 right

right endpoint of range (zero based)

This structure keeps track of the regions aligned between the query sequence and those that were not ...

SSeqRange * pos_extnt

Dynamically allocated array of size query_length to keep track of the extents of each aligned positio...

Uint4 * size

Dynamically allocated array of size query_length that contains the size of the intervals in the array...

Auxiliary structure to maintain information about two aligned regions between the query and a subject...

Uint4 n_x_residues

number of X residues in alignment

Uint4 n_identical

number of identical residues in alignment

Uint4 start

starting offset of alignment w.r.t.

Uint4 effective_length

length of alignment not including Xs

Internal representation of a PSSM in various stages of its creation and its dimensions.

int ** scaled_pssm

scaled PSSM (scores)

Uint4 nrows

number of rows (alphabet_size)

double * pseudocounts

pseudocount constant for each column

int ** pssm

PSSM (scores)

Uint4 ncols

number of columns (query_length)

double ** freq_ratios

frequency ratios

Internal data structure to represent a position in the multiple sequence alignment data structure.

unsigned int letter

Preferred letter at this position.

SSeqRange extents

Extents of this aligned position.

unsigned int is_aligned

Is this letter part of the alignment?

Internal multiple alignment data structure used by the PSSM engine.

Uint4 * num_matching_seqs

number of sequences aligned at a given position in the multiple sequence alignment (length: query_len...

Uint1 * query

query sequence (length: query_length)

Uint4 ** residue_counts

matrix to keep track of the raw residue counts at each position of the multiple sequence alignment (d...

PSIMsaDimensions * dimensions

dimensions of field below

Uint4 alphabet_size

number of elements in alphabet

_PSIMsaCell ** cell

multiple sequence alignment matrix (dimensions: query_length x num_seqs + 1)

Compact version of the PSIMsaCell structure.

unsigned int letter

Preferred letter at this position, in ncbistdaa encoding.

unsigned int is_aligned

Is this letter part of the alignment?

Compact version of PSIMsa structure.

PSIMsaDimensions * dimensions

dimensions of the msa

Boolean * use_sequence

used to indicate whether a sequence should be used for further processing by the engine (length: num_...

_PSIPackedMsaCell ** data

actual data, dimensions are (dimensions->num_seqs+1) by (dimensions->query_length)

Internal data structure to keep computed sequence weights.

double ** match_weights

weighted observed residue frequencies (f_i in 2001 paper).

Uint4 posDistinctDistrib_size

Kept to deallocate field above.

double * std_prob

standard amino acid probabilities

double * norm_seq_weights

Stores the normalized sequence weights (length: num_seqs + 1)

int ** posDistinctDistrib

For position i, how many positions in its block have j distinct letters.

double * independent_observations

Number of independent sequences per column.

int * posNumParticipating

number of sequences at each position.

double * sigma

array of length query_length

double * gapless_column_weights

FIXME.

Uint4 match_weights_size

kept for help deallocate the field above

double * row_sigma

array of length num_seqs + 1

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