~ubuntu-branches/ubuntu/feisty/ncbi-tools6/feisty

 * ===========================================================================

 *

 *                            PUBLIC DOMAIN NOTICE

#define __BLAST_STAT__

 

#include <algo/blast/core/blast_def.h>

#include <algo/blast/core/blast_message.h>

 

#ifdef __cplusplus

 * @return NULL in case of memory allocation failure, else new

 * SPsiBlastScoreMatrix structure

 */

SPsiBlastScoreMatrix*

SPsiBlastScoreMatrixNew(size_t ncols);

 

 * @param matrix structure to deallocate [in]

 * @return NULL

 */

SPsiBlastScoreMatrix*

SPsiBlastScoreMatrixFree(SPsiBlastScoreMatrix* matrix);

 

 * @param number_of_contexts how many strands or sequences [in]

 * @return BlastScoreBlk*

*/

BlastScoreBlk* BlastScoreBlkNew (Uint1 alphabet, Int4 number_of_contexts);

 

/** Deallocates BlastScoreBlk as well as all associated structures.

 * @param sbp BlastScoreBlk to be deallocated [in]

 * @return NULL pointer.

 */

BlastScoreBlk* BlastScoreBlkFree (BlastScoreBlk* sbp);

 

/** Set the ambiguous residue (e.g, 'N', 'X') in the BlastScoreBlk*.

 * @param ambiguous_res the residue to be set on the BlastScoreBlk

 * @return zero on success, others on error

 */

Int2 BLAST_ScoreSetAmbigRes (BlastScoreBlk* sbp, char ambiguous_res);

 

 

/** Calculate and fill the ungapped Karlin-Altschul parameters in the

 * @param program BLAST program type, needed to decide whether to substitute

 *                ideal values. [in]

 * @param sbp Scoring block to work with [in] [out]

 * @param query Buffer containing (concatenated) query sequence [in]

 * @param query_info Information about offsets of concatenated queries [in]

 */

Int2

Blast_ScoreBlkKbpUngappedCalc(EBlastProgramType program, 

                              BlastScoreBlk* sbp, Uint1* query, 

 

/** This function fills in the BlastScoreBlk structure.  

 * Tasks are:

 * @param sbp Scoring block [in] [out]

 * @param matrix Full path to the matrix in the directory structure [in]

*/

Int2 Blast_ScoreBlkMatrixFill (BlastScoreBlk* sbp, char* matrix);

 

/** Callocs a Blast_KarlinBlk

 * @return pointer to the Blast_KarlinBlk

*/

Blast_KarlinBlk* Blast_KarlinBlkNew (void);

 

/** Copies contents of one Karlin block to another. Both must be allocated

 * @param kbp_from Karlin block to copy values from [in]

 * @return 0 on success; -1 if either argument is NULL on input.

 */ 

Int2 Blast_KarlinBlkCopy(Blast_KarlinBlk* kbp_to, Blast_KarlinBlk* kbp_from);

 

 

 * @param kbp KarlinBlk to be deallocated [in]

 * @return NULL

*/

Blast_KarlinBlk* Blast_KarlinBlkFree(Blast_KarlinBlk* kbp);

 

/** Fills in lambda, H, and K values, as calculated by Stephen Altschul 

 * @param error_return filled in with error message if needed [out]

 * @return zero on success

 */

Int2 Blast_KarlinBlkGappedCalc (Blast_KarlinBlk* kbp, Int4 gap_open, 

        Int4 gap_extend, Int4 decline_align, const char* matrix_name, 

        Blast_Message** error_return);

 *      score in some cases [in|out]

 * @param error_return Pointer to error message. [in] [out]

 */

Int2

Blast_KarlinBlkNuclGappedCalc(Blast_KarlinBlk* kbp, Int4 gap_open, 

                              Int4 gap_extend, Int4 reward, Int4 penalty,

 * @param sbp ScoreBlk used to calculate "ideal" values. [in|out]

 * @return 0 on success, 1 on failure

*/

Int2 Blast_ScoreBlkKbpIdealCalc(BlastScoreBlk* sbp);

 

/** Attempts to fill KarlinBlk for given gap opening, extensions etc.

 *          1 if matrix not found

 *           2 if matrix found, but open, extend etc. values not supported.

*/

Int2 Blast_KarlinBlkGappedLoadFromTables(Blast_KarlinBlk* kbp, Int4 gap_open, Int4 gap_extend, Int4 decline_align, const char* matrix_name);

 

/** Prints a messages about the allowed matrices, BlastKarlinBlkGappedFill should return 1 before this is called. 

 * @param matrix the matrix to print a message about [in]

 * @return the message

 */

char* BLAST_PrintMatrixMessage(const char *matrix);

 

/** Prints a messages about the allowed open etc values for the given matrix, 

 * @param decline_align cost of declining to align [in]

 * @return message

 */

char* BLAST_PrintAllowedValues(const char *matrix, Int4 gap_open, Int4 gap_extend, Int4 decline_align);

 

/** Calculates the parameter Lambda given an initial guess for its value */

double

Blast_KarlinLambdaNR(Blast_ScoreFreq* sfp, double initialLambdaGuess);

 

 * @param searchsp total search space to be used [in]

 * @return the expect value

 */

double BLAST_KarlinStoE_simple (Int4 S, Blast_KarlinBlk* kbp, Int8  searchsp);

 

/** Compute a divisor used to weight the evalue of a collection of

 * @param nsegs the number of HSPs in the sum group [in]

 * @return divisor used to compensate for multiple tests

 */

double BLAST_GapDecayDivisor(double decayrate, unsigned nsegs );

 

/** Calculate the cutoff score from the expected number of HSPs or vice versa.

 * @param dodecay Use gap decay feature? [in]

 * @param gap_decay_rate Gap decay rate to use, if dodecay is set [in]

 */

Int2 BLAST_Cutoffs (Int4 *S, double* E, Blast_KarlinBlk* kbp, 

                    Int8 searchsp, Boolean dodecay, double gap_decay_rate);

 

 *    the calling routine [in]

 * @return the expect value 

 */

double BLAST_SmallGapSumE (Int4 start_points, Int2 num,  double xsum,

                           Int4 query_length, Int4 subject_length,

                           Int8 searchsp_eff, double weight_divisor);

 *    the calling routine [in]

 * @return sum expect value.

 */

double BLAST_UnevenGapSumE (Int4 query_start_points, Int4 subject_start_points,

                            Int2 num, double xsum,

                            Int4 query_length, Int4 subject_length,

 *    calling routine [in]

 * @return sum expect value.

 */

double BLAST_LargeGapSumE (Int2 num,  double xsum,

                           Int4 query_length, Int4 subject_length,

                           Int8 searchsp_eff, double weight_divisor );

 * @param gap_extension returns recommended extension cost [in|out]

 * @return zero on success 

 */

Int2 BLAST_GetProteinGapExistenceExtendParams(const char* matrixName,

                                       Int4* gap_existence,

                                       Int4* gap_extension);

 * @param gap_extension returns recommended extension cost [in|out]

 * @return zero on success 

 */

Int2 BLAST_GetNucleotideGapExistenceExtendParams(Int4 reward,

                                       Int4 penalty,

                                       Int4* gap_existence,

 * @param gap_extend extension cost of a gap [in]

 * @param kbp_ungapped Karlin block with ungapped values of the parameters [in]

*/

void BLAST_GetAlphaBeta (const char* matrixName, double *alpha,

                         double *beta, Boolean gapped, Int4 gap_open, 

                         Int4 gap_extend, const Blast_KarlinBlk* kbp_ungapped);

 * @param alpha Alpha parameter for this scoring system [out]

 * @param beta Beta parameter for this scoring system [out]

 */

Int2 Blast_GetNuclAlphaBeta(Int4 reward, Int4 penalty, Int4 gap_open, 

                            Int4 gap_extend, Blast_KarlinBlk* kbp,

                            Boolean gapped_calculation,

 * @param matrix_name Name of the score matrix underlying the RPS search [in]

 * @return rescaled pssm 

 */

Int4 ** RPSRescalePssm(double scalingFactor, Int4 rps_query_length, 

                   const Uint1 * rps_query_seq, Int4 db_seq_length, 

                   Int4 **posMatrix, const char *matrix_name);

 * @return   0 if length_adjustment is known to be the largest integer less

 *           than the fixed point of f(ell); 1 otherwise.

 */

Int4

BLAST_ComputeLengthAdjustment(double K,

                              double logK,

    based upon the contents of sbp.

 * @param sbp The BlastScoreBlk* used to init prob [in]

*/

Blast_ResFreq* Blast_ResFreqNew(const BlastScoreBlk* sbp);

 

/** Deallocates Blast_ResFreq and prob0 element.

 * @param rfp the Blast_ResFreq to be deallocated.

*/

Blast_ResFreq* Blast_ResFreqFree(Blast_ResFreq* rfp);

 

 

 * @param rfp the prob element on this Blast_ResFreq is used.

 * @return zero on success

*/

Int2 Blast_ResFreqStdComp(const BlastScoreBlk* sbp, Blast_ResFreq* rfp);

 

/** Creates a new structure to keep track of score frequencies for a scoring

 * @param score_max Maximum score [in]

 * @return allocated and initialized pointer to Blast_ScoreFreq

 */

Blast_ScoreFreq*

Blast_ScoreFreqNew(Int4 score_min, Int4 score_max);

 

 * @param sfp the structure to deallocate [in]

 * @return NULL

 */

Blast_ScoreFreq*

Blast_ScoreFreqFree(Blast_ScoreFreq* sfp);

 

 * @param residue_size size of "residues" buffer [in]

 * @return Number of residues in alphabet or negative returns upon error.

 */

Int2

Blast_GetStdAlphabet(Uint1 alphabet_code, Uint1* residues, 

                     Uint4 residue_size);

 * @param sfp array of probabilities for all scores [in]

 * @return zero on success, 1 on error.

 */

Int2

Blast_KarlinBlkUngappedCalc(Blast_KarlinBlk* kbp, Blast_ScoreFreq* sfp);

 

 * @param length the length of the sequence [in]

 * @param resProb the object to be filled in [in|out]

 */

void

Blast_FillResidueProbability(const Uint1* sequence, Int4 length, double * resProb);

 

 [in|out]

 * @return zero on success.

*/

Int2 BlastScoreBlkNuclMatrixCreate(BlastScoreBlk* sbp);

 

#ifdef __cplusplus