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

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

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

{1,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,22};

{(-1), 0, (-1), 4, 3, 6, 13, 7, 8, 9, 11, 10, 12, 2, 14, 5, 1, 15,

16, 19, 17, (-1), 18, (-1), (-1), (-1), (-1), (-1)};

{{4, -1, -2, -2, 0, -1, -1, 0, -2, -1, -1, -1, -1, -2, -1, 1, 0, -3, -2, 0},

{-1, 5, 0, -2, -3, 1, 0, -2, 0, -3, -2, 2, -1, -3, -2, -1, -1, -3, -2, -3},

{-2, 0, 6, 1, -3, 0, 0, 0, 1, -3, -3, 0, -2, -3, -2, 1, 0, -4, -2, -3},

{-2, -2, 1, 6, -3, 0, 2, -1, -1, -3, -4, -1, -3, -3, -1, 0, -1, -4, -3, -3},

{0,-3,-3,-3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1},

{-1, 1, 0, 0, -3, 5, 2, -2, 0, -3, -2, 1, 0, -3, -1, 0, -1, -2, -1, -2},

{-1, 0, 0, 2, -4, 2, 5, -2, 0, -3, -3, 1, -2, -3, -1, 0, -1, -3, -2, -2},

{0, -2, 0, -1, -3, -2, -2, 6, -2, -4, -4, -2, -3, -3, -2, 0, -2, -2, -3, -3},

{-2, 0, 1, -1, -3, 0, 0, -2, 8, -3, -3, -1, -2, -1, -2, -1, -2, -2, 2, -3},

{-1, -3, -3, -3, -1, -3, -3, -4, -3, 4, 2, -3, 1, 0, -3, -2, -1, -3, -1, 3},

{-1, -2, -3, -4, -1, -2, -3, -4, -3, 2, 4, -2, 2, 0, -3, -2, -1, -2, -1, 1},

{-1, 2, 0, -1, -3, 1, 1, -2, -1, -3, -2, 5, -1, -3, -1, 0, -1, -3, -2, -2},

{-1, -1, -2, -3, -1, 0, -2, -3, -2, 1, 2, -1, 5, 0, -2, -1, -1, -1, -1, 1},

{-2, -3, -3, -3, -2, -3, -3, -3, -1, 0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1},

{-1,-2,-2,-1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2},

{1, -1, 1, 0, -1, 0, 0, 0, -1, -2, -2, 0, -1, -2, -1, 4, 1, -3, -2, -2},

{0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 1, 5, -2, -2, 0},

{-3,-3,-4,-4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3},

{-2, -2, -2, -3, -2, -1, -2, -3, 2, -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1},

{0, -3, -3, -3, -1, -2, -2, -3, -3, 3, 1, -2, 1, -1, -2, -2, 0, -3, -1, 4}};

number_of_observations,

* background_probs20,

dpseudocounts = pseudocounts;

= dpseudocounts / (number_of_observations + dpseudocounts);

probs20[

] = (1.0 -

) * probs20[

] / sum

+

* background_probs20[

];

temp = (

[

] +

[

]) / 2;

sqrt(

);

**score,

alphsize,

row_prob[],

col_prob[],

lambda_tolerance,

function_tolerance,

left = 0, right = 1;

x = 0.367879441171;

avg_score = 0.0;

(

= 0;

< alphsize;

++) {

(row_prob[

] == 0.0) {

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

(col_prob[j] == 0.0) {

(max_score < score[

][j]) {

max_score = score[

][j];

avg_score += row_prob[

] * col_prob[j] * score[

][j];

(max_score <= 0.0 || avg_score >= 0) {

*piterations = max_iterations;

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

x_pow_max_score;

was_newton = is_newton;

x_pow_max_score = exp(-max_score *

);

= -x_pow_max_score;

slope = max_score *

/ x;

(

= 0;

< alphsize;

++) {

(row_prob[

] == 0.0) {

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

(col_prob[j] == 0.0) {

(max_score != score[

][j]) {

diff_score = max_score - score[

][j];

ff = row_prob[

] * col_prob[j] * exp(-

* diff_score);

slope += diff_score * ff / x;

ff = row_prob[

] * col_prob[j];

(right - left <= 2 * left * (1 - right) * lambda_tolerance &&

(

/x_pow_max_score) <= function_tolerance) {

x = (left + right) / 2;

((was_newton &&

(

) > .9 *

(fold))

x = (left + right)/2;

p = -

/slope;

(y <= left || y >= right) {

x = (left + right)/2;

(

(p) <= lambda_tolerance * x * (1-x) &&

(

/x_pow_max_score) <= function_tolerance)

;

*plambda = (k < max_iterations) ? -

(x) : -1.0;

col_prob[],

Lambda)

entropy = 0.0;

(

= 0;

< alphsize;

++) {

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

nat_score = Lambda * matrix[

][j];

entropy += nat_score * exp(nat_score) * row_prob[

] * col_prob[j];

row_prob[

] += target_freq[

][j];

col_prob[j] += target_freq[

][j];

freq = target_freq[

][j];

entropy += freq *

(freq / row_prob[

] / col_prob[j]);

row_prob[],

col_prob[])

(

= 0;

< alphsize;

++) {

(row_prob[

] > 0) {

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

(col_prob[j] > 0) {

ratios[

][j] /= (row_prob[

] * col_prob[j]);

(

= 0;

< rows;

++) {

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

(0.0 == matrix[

][j]) {

matrix[

][j] =

(matrix[

][j])/Lambda;

* inputLetterProbs,

alphsize)

(c = 0; c < alphsize; c++) {

outputLetterProbs[

[c]] = inputLetterProbs[c];

(c = 0; c < alphsize; c++) {

** target_freq,

row_prob[],

col_prob[])

(scores ==

) {

old_row_prob[

] += target_freq[

][j];

old_col_prob[j] += target_freq[

][j];

old_row_prob, old_col_prob);

row_prob, col_prob, *Lambda);

(

= 0;

< small_alphsize;

++) {

(

= 0;

< small_alphsize;

++) {

sum += freq[

][

];

(

= 0;

< StdAlphsize;

++) {

(

= 0;

< StdAlphsize;

++) {

StdFreq[

][

] = 0.0;

(

= 0;

< StdAlphsize;

++) {

StdFreq[

][

] = 0.0;

StdFreq[

][

] = freq[

][

] / sum;

(StdAlphsize >

) {

memcpy(StdFreq[

], StdFreq[

], StdAlphsize *

(

));

memcpy(StdFreq[

], StdFreq[

], StdAlphsize *

(

));

(StdAlphsize >

) {

memcpy(StdFreq[

],StdFreq[

], StdAlphsize *

(

));

score_iX = 0.0;

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

score_iX +=

[j * incM] * probs[j];

row_probs[],

col_probs[])

score_XX = 0.0;

cols = alphsize;

(

= 0;

< alphsize;

++) {

score_XX += avg_iX * row_probs[

];

( alphsize >

) {

(

= 0;

< alphsize;

++) {

memcpy(

[

],

[

], alphsize *

(

));

(

= 0;

< alphsize;

++) {

x += (x >= 0. ? 0.5 : -0.5);

**floatScoreMatrix)

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

(c = 0; c < cols; c++) {

(floatScoreMatrix[p][c] < INT_MIN) {

matrix[p][c] = INT_MIN;

matrix[p][c] =

(floatScoreMatrix[p][c]);

** target_freq,

** StartMatrix,

row_prob[],

col_prob[],

(Scores ==

) {

(

= 0;

< Alphsize;

++) {

** matrix,

rows)

minScore, maxScore;

minScore = maxScore = 0;

(irow = 0; irow < rows; irow++) {

(matrix[irow][jcol] < minScore &&

minScore = matrix[irow][jcol];

(matrix[irow][jcol] > maxScore)

maxScore = matrix[irow][jcol];

**matrix,

alphsize,

*subjectProbArray,

*queryProbArray)

range = *obs_max - *obs_min + 1;

*scoreProb =

(range,

(

));

(*scoreProb ==

) {

sprob = &((*scoreProb)[-(*obs_min)]);

(irow = 0; irow < alphsize; irow++) {

(matrix[irow][jcol] >= minScore) {

sprob[matrix[irow][jcol]] +=

(queryProbArray[irow] * subjectProbArray[jcol]);

**matrix,

rows,

*subjectProbArray)

range = *obs_max - *obs_min + 1;

*scoreProb =

(range,

(

));

(*scoreProb ==

) {

sprob = &((*scoreProb)[-(*obs_min)]);

onePosFrac = 1.0/ ((double) rows);

(irow = 0; irow < rows; irow++) {

(matrix[irow][jcol] >= minScore) {

sprob[matrix[irow][jcol]] +=

onePosFrac * subjectProbArray[jcol];

** freq,

Lambda)

dMatrix[0] = dMatrixStore;

(

= 0;

< alphsize;

++) {

memcpy(dMatrix[0], freq[

], alphsize *

(

));

((*ss)->matrixName);

(

= 0;

< cols;

++) {

(

**matrix,

rows,

cols,

** freq_ratios,

** start_matrix,

col_prob[],

Lambda)

* row_matrix[1];

row_matrix[0] =

;

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

memcpy(

, freq_ratios[p], cols *

(

));

** freq_ratios,

** start_matrix,

row_prob[],

col_prob[],

(scores == 0)

-1;

(

= 0;

< alphsize;

++) {

memcpy(scores[

], freq_ratios[

], alphsize *

(

));

(

= 0;

< alphsize;

++) {

queryProb[],

resProb[],

(*calc_lambda)(

*,

,

,

),

pValueAdjustment)

correctUngappedLambda;

obs_min, obs_max;

resProb, queryProb);

correctUngappedLambda =

(0 == pValueAdjustment)

*LambdaRatio =

(1, *LambdaRatio);

(*LambdaRatio > 0) {

queryProb, resProb, scaledLambda);

* sequence,

length)

numTrueAminoAcids = 0;

*

= composition->

;

(

= 0;

< alphsize;

++) {

(

= 0;

< length;

++) {

[sequence[

]]++;

numTrueAminoAcids++;

(numTrueAminoAcids > 0) {

(

= 0;

< alphsize;

++) {

[

] /= numTrueAminoAcids;

* subject_data,

length,

start,

finish)

(

= left;

> 0;

--) {

(

= right;

< length;

++) {

*pleft = left; *pright = right;

(NRrecord !=

) {

(NRrecord ==

)

error_return;

(NRrecord->

==

)

error_return;

*matrixName)

,

* stdaa_row_probs,

* stdaa_col_probs,

iteration_count, status;

, desired_re = 0.0;

(matrix_adjust_rule) {

row_probs, col_probs);

(status > 0)

desired_re = specifiedRE;

fprintf(stderr,

);

&NRrecord->

[0][0],

row_probs, col_probs,

row_probs, col_probs,

RE_pseudocounts,

calc_lambda(

*,

,

,

),

*pvalueForThisPair,

compositionTestIndex,

*ratioToPassBack)

alphsize = matrixInfo->

;

lambdaForPair;

((compositionTestIndex > 0) ||

query_composition->

, alphsize);

subject_composition->

, alphsize);

(compositionTestIndex > 0) {

(scores ==

) {

*matrix_adjust_rule =

composition_adjust_mode);

*matrix_adjust_rule,

subject_composition->

query_composition->

,

subject_composition->

,

*ratioToPassBack = 1.0;

query_composition->

,

subject_composition->

,

(compositionTestIndex > 0));

EMatrixAdjustRule Blast_ChooseMatrixAdjustRule(int length1, int length2, const double *probArray1, const double *probArray2, const char *matrixName, ECompoAdjustModes composition_adjust_mode)

Choose how the relative entropy should be constrained based on properties of the two sequences to be ...

Blast_CompositionWorkspace * Blast_CompositionWorkspaceNew(void)

Create a new Blast_CompositionWorkspace object, allocating memory for all its component arrays.

void Blast_ApplyPseudocounts(double *probs20, int number_of_observations, const double *background_probs20, int pseudocounts)

Find the weighted average of a set of observed probabilities with a set of "background" probabilities...

static double s_CalcXScore(double *M, int alphsize, int incM, const double probs[])

Calculate values for the X ambiguity score, give an vector of scores and a set of character probabili...

static void s_UnpackLetterProbs(double std_probs[], int alphsize, const double probs[])

Convert letter probabilities from a a 20 letter ARND...

int Blast_AdjustScores(int **matrix, const Blast_AminoAcidComposition *query_composition, int queryLength, const Blast_AminoAcidComposition *subject_composition, int subjectLength, const Blast_MatrixInfo *matrixInfo, ECompoAdjustModes composition_adjust_mode, int RE_pseudocounts, Blast_CompositionWorkspace *NRrecord, EMatrixAdjustRule *matrix_adjust_rule, double calc_lambda(double *, int, int, double), double *pvalueForThisPair, int compositionTestIndex, double *ratioToPassBack)

Compute a compositionally adjusted scoring matrix.

static int alphaConvert[COMPO_LARGEST_ALPHABET]

conversion from 26 letter NCBIstdaa alphabet to 20 letter order for true amino acids: ARNDCQEGHILKMFP...

static void s_ScalePSSM(int **matrix, int rows, int cols, double **freq_ratios, int **start_matrix, const double col_prob[], double Lambda)

Fill in all scores for a PSSM at a given scale Lambda.

static void s_SetXUOScores(double **M, int alphsize, const double row_probs[], const double col_probs[])

Given a standard matrix with the scores for true amino acid, and pairwise ambiguity scores set,...

static double s_CalcAvgScore(double *M, int alphsize, int incM, const double probs[])

Calculate the average score of a row or column of a matrix.

int Blast_CompositionWorkspaceInit(Blast_CompositionWorkspace *NRrecord, const char *matrixName)

Initialize the fields of a Blast_CompositionWorkspace for a specific underlying scoring matrix.

static const double kCompoAdjustErrTolerance

bound on error for Newton's method

static const int kCompositionMargin

Desired margin between an end of region used for computing a composition, and the nearest StopChar; t...

int Blast_EntropyOldFreqNewContext(double *entropy, double *Lambda, int *iter_count, double **target_freq, const double row_prob[], const double col_prob[])

Compute the relative entropy of the scoring matrix that is consistent with a set of target frequencie...

static int trueCharPositions[COMPO_NUM_TRUE_AA]

positions of true characters in protein alphabet

static void s_GetScoreRange(int *obs_min, int *obs_max, int **matrix, int rows)

Find the range of scores contained in an scoring matrix.

void Blast_Int4MatrixFromFreq(int **matrix, int alphsize, double **freq, double Lambda)

Compute an integer-valued amino-acid score matrix from a set of score frequencies.

static const double kLambdaFunctionTolerance

bound on the difference between the expected value of exp(lambda x S) and 1

void Blast_FreqRatioToScore(double **matrix, int rows, int cols, double Lambda)

Convert a matrix of frequency ratios to a matrix of scores.

static void s_SetPairAmbigProbsToSum(double probs[], int alphsize)

Set the probabilities for the two-character ambiguity characters.

static int s_GetMatrixScoreProbs(double **scoreProb, int *obs_min, int *obs_max, int **matrix, int alphsize, const double *subjectProbArray, const double *queryProbArray)

Compute the score probabilities for a given amino acid substitution matrix in the context of given qu...

static const double kFixedReBlosum62

relative entropy of BLOSUM62

static void s_RoundScoreMatrix(int **matrix, int rows, int cols, double **floatScoreMatrix)

Round a floating point matrix of scores to produce an integer matrix of scores.

static int s_GetPssmScoreProbs(double **scoreProb, int *obs_min, int *obs_max, int **matrix, int rows, const double *subjectProbArray)

Compute the score probabilities for a given amino acid position-specific substitution matrix in the c...

Blast_MatrixInfo * Blast_MatrixInfoNew(int rows, int cols, int positionBased)

Create a Blast_MatrixInfo object.

double Blast_GetRelativeEntropy(const double A[], const double B[])

Compute the symmetric form of the relative entropy of two probability vectors.

double Blast_TargetFreqEntropy(double **target_freq)

Compute the entropy of the scoring matrix implicit in a set of target substitution frequencies.

static void s_GatherLetterProbs(double *outputLetterProbs, const double *inputLetterProbs, int alphsize)

Convert letter probabilities from the NCBIstdaa alphabet to a 20 letter ARND...

static const double kLambdaErrorTolerance

bound on error for estimating lambda

int Blast_CompositionMatrixAdj(int **matrix, int alphsize, EMatrixAdjustRule matrix_adjust_rule, int length1, int length2, const double *stdaa_row_probs, const double *stdaa_col_probs, int pseudocounts, double specifiedRE, Blast_CompositionWorkspace *NRrecord, const Blast_MatrixInfo *matrixInfo)

Use compositional score matrix adjustment, as described in.

void Blast_MatrixInfoFree(Blast_MatrixInfo **ss)

Free memory associated with a Blast_MatrixInfo object.

int Blast_CompositionBasedStats(int **matrix, double *LambdaRatio, const Blast_MatrixInfo *ss, const double queryProb[], const double resProb[], double(*calc_lambda)(double *, int, int, double), int pValueAdjustment)

Use composition-based statistics to adjust the scoring matrix, as described in.

static const int kLambdaIterationLimit

iteration limit for Newton's method for computing Lambda

static int s_ScaleSquareMatrix(int **matrix, int alphsize, double **freq_ratios, int **start_matrix, const double row_prob[], const double col_prob[], double Lambda)

Fill in all scores for a scoring matrix for the NCBIstdaa alphabet at a given scale Lambda.

static int s_ScoresStdAlphabet(int **Matrix, int Alphsize, double **target_freq, int **StartMatrix, const double row_prob[], const double col_prob[], double Lambda)

Given a set of target frequencies and two sets of character probabilities for the true amino acids in...

#define LambdaRatioLowerBound

LambdaRatioLowerBound is used when the expected score is too large causing impalaKarlinLambdaNR to gi...

void Blast_TrueAaToStdTargetFreqs(double **StdFreq, int StdAlphsize, double **freq)

Convert a matrix of target frequencies for the ARND alphabet of true amino acids to a set of target f...

void Blast_GetCompositionRange(int *pleft, int *pright, const Uint1 *subject_data, int length, int start, int finish)

Get the range of a sequence to be included when computing a composition.

static double BLOS62[COMPO_NUM_TRUE_AA][COMPO_NUM_TRUE_AA]

The BLOSUM62 matrix for the ARND...

void Blast_CalcLambdaFullPrecision(double *plambda, int *piterations, double **score, int alphsize, const double row_prob[], const double col_prob[], double lambda_tolerance, double function_tolerance, int max_iterations)

Given a score matrix the character frequencies in two sequences, compute the ungapped statistical par...

double Blast_MatrixEntropy(double **matrix, int alphsize, const double row_prob[], const double col_prob[], double Lambda)

Calculate the entropy of a matrix relative to background probabilities for two sequences.

void Blast_CalcFreqRatios(double **ratios, int alphsize, double row_prob[], double col_prob[])

Given a matrix of target frequencies, divide all elements by the character probabilities to get a mat...

static const int kCompoAdjustIterationLimit

iteration limit for Newton's method

static long Nint(double x)

Return the nearest integer to x.

static const double kMaximumXscore

largest permitted value of score(i,X), when scores are computed using composition adjustment

void Blast_CompositionWorkspaceFree(Blast_CompositionWorkspace **pNRrecord)

Free memory associated with a record of type Blast_CompositionWorkspace.

void Blast_ReadAaComposition(Blast_AminoAcidComposition *composition, int alphsize, const Uint1 *sequence, int length)

Compute the true amino acid composition of a sequence, ignoring ambiguity characters and other nonsta...

Definitions used in compositional score matrix adjustment.

Constants used in compositional score matrix adjustment.

ECompoAdjustModes

An collection of constants that specify all permissible modes of composition adjustment.

@ eCompositionBasedStats

Composition-based statistics as in NAR 29:2994-3005, 2001.

#define COMPO_NUM_TRUE_AA

Number of standard amino acids.

EMatrixAdjustRule

An collection of constants that specify all rules that may be used to generate a compositionally adju...

@ eRelEntropyOldMatrixOldContext

@ eRelEntropyOldMatrixNewContext

@ eUserSpecifiedRelEntropy

@ eUnconstrainedRelEntropy

#define COMPO_LARGEST_ALPHABET

The largest alphabet supported by this code (the code supports 26 or 28 character amino acid alphabet...

#define COMPO_SCORE_MIN

Minimum score in a matrix.

uint8_t Uint1

1-byte (8-bit) unsigned integer

Definitions used to get joint probabilities for a scoring matrix.

int Blast_GetJointProbsForMatrix(double **probs, double row_sums[], double col_sums[], const char *matrixName)

Get joint probabilities for the named matrix.

const GenericPointer< typename T::ValueType > T2 value

Type and macro definitions from C toolkit that are not defined in C++ toolkit.

#define MIN(a, b)

returns smaller of a and b.

#define MAX(a, b)

returns larger of a and b.

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

Declarations for several linear algebra routines.

double ** Nlm_DenseMatrixNew(int nrows, int ncols)

Create and return a new, dense matrix.

void Nlm_DenseMatrixFree(double ***mat)

Free a matrix created by Nlm_DenseMatrixNew or Nlm_LtriangMatrixNew.

void Nlm_AddVectors(double y[], int n, double alpha, const double x[])

Let y = y + alpha * x.

void Nlm_Int4MatrixFree(int ***mat)

Free a matrix created by Nlm_DenseMatrixNew or Nlm_LtriangMatrixNew.

int ** Nlm_Int4MatrixNew(int nrows, int ncols)

Create and return a new Int4 matrix.

Routines for finding an optimal set of target frequencies for the purpose of generating a composition...

int Blast_OptimizeTargetFrequencies(double x[], int alphsize, int *iterations, const double q[], const double row_sums[], const double col_sums[], int constrain_rel_entropy, double relative_entropy, double tol, int maxits)

Find an optimal set of target frequencies for the purpose of generating a compositionally adjusted sc...

#define row(bind, expected)

Represents the composition of an amino-acid sequence, in the ncbistdaa alphabet.

int numTrueAminoAcids

number of true amino acids in the sequence, omitting nonstandard amino acids

double prob[COMPO_LARGEST_ALPHABET]

probabilities of each amino acid

Work arrays used to perform composition-based matrix adjustment.

double * first_standard_freq

background frequency vector of the first sequence

double ** mat_final

optimized target frequencies

double * second_standard_freq

background frequency vector of the second sequence

double ** mat_b

joint probabilities for the matrix in standard context

Information about a amino-acid substitution matrix.

double ** startFreqRatios

frequency ratios used to calculate matrix scores

int cols

the number of columns in the scoring matrix, i.e.

char * matrixName

name of the matrix

int positionBased

is the matrix position-based

int rows

the number of rows in the scoring matrix.

double ungappedLambda

ungapped Lambda value for this matrix in standard context

int ** startMatrix

Rescaled values of the original matrix.

Headers for computing a "composition" p-value of a match, and for computing a unified p-value combini...

#define COMPO_MIN_LAMBDA

the smallest value of lambda in the table of lambda's empirical distribution function.

double Blast_CompositionPvalue(double lambda)

Conditionally compute a compositional p-value.

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