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

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

NCBI C++ ToolKit: src/algo/blast/unit_tests/api/linkhsp_unit_test.cpp Source File

;

(*query_info)->contexts[0].query_offset = 0;

(*query_info)->contexts[0].query_length = query_length;

(*query_info)->contexts[1].query_offset = query_length + 1;

(*query_info)->contexts[1].query_length = query_length;

(*query_info)->max_length = query_length;

kNumHsps = 10;

kScores[kNumHsps] =

{ 1023, 282, 246, 202, 142, 117, 98, 92, 63, 53 };

kQueryOffsets[kNumHsps] =

{ 11, 346, 399, 244, 287, 224, 311, 218, 0, 404};

kQueryLengths[kNumHsps] =

{ 244, 56, 49, 49, 104, 29, 36, 37, 12, 25 };

kSubjectFrames[kNumHsps] =

{ 2, 2, 3, 2, 1, 1, 2, 3, 3, 2 };

kSubjectOffsets[kNumHsps] =

{ 1372, 2677, 2756, 2062, 2209, 1832, 2351, 1732, 1140, 2683 };

kSubjectLengths[kNumHsps] =

{300, 56, 49, 50, 75, 29, 32, 36, 12, 26 };

(index = 0; index < kNumHsps; ++index) {

hsp->

= kScores[index];

hsp->

.

= kQueryOffsets[index] + kQueryLengths[index];

kSubjectOffsets[index] + kSubjectLengths[index];

kSubjectOffsets[index] + kSubjectLengths[index];

hsp->

.

= kQueryOffsets[index] + kQueryLengths[index];

m_HspList->

= kNumHsps;

BOOST_REQUIRE(!

(

, score_options->

));

BOOST_REQUIRE(status == 0);

seqbuf, m_QueryInfo, &message);

BOOST_REQUIRE(message ==

);

BOOST_REQUIRE(status == 0);

m_ProgramType, m_QueryInfo,

);

BOOST_REQUIRE(status == 0);

(score_options_ptr)

*score_options_ptr = score_options;

db_num_seq, &eff_len_params);

m_ScoreBlk, m_QueryInfo,

);

kProtGi =

;

kNuclGi =

;

kProtLength = 448;

kNuclLength = 8872;

unique_ptr<SSeqLoc> qsl(

query_v.push_back(*qsl);

unique_ptr<SSeqLoc> qsl(

query_v.push_back(*qsl);

(query_v, m_ProgramType, strand_opt, &m_QueryInfo);

m_ProgramType, strand_opt, blast_msg);

BOOST_REQUIRE(m->empty());

setupScoreBlk(query_blk->

,

, &score_options);

kNuclLength / 3 : kProtLength);

fillEffectiveLengths(score_options, (

)m_SubjectLength, 1);

kNumHsps = 8;

kLongestIntron = 4000;

kNumsLinked[kNumHsps] = { 1, 5, 5, 5, 2, 5, 5, 2 };

kScores[kNumHsps] = { 1023, 282, 246, 202, 142, 117, 98, 92 };

setupLinkHspInputTblastn();

setupHSPListTransl();

setupHitParams(kLongestIntron,

);

(m_ProgramType, m_HspList, m_QueryInfo, m_SubjectLength,

BOOST_REQUIRE_EQUAL(kNumHsps, m_HspList->

);

(

index = 0; index < kNumHsps; ++index) {

BOOST_REQUIRE_EQUAL(kNumsLinked[index], m_HspList->

[index]->

);

BOOST_REQUIRE_EQUAL(kScores[index], m_HspList->

[index]->

);

kNumHsps = 5;

kScores[kNumHsps] =

{ 80, 60, 55, 54, 52 };

kQueryOffsets[kNumHsps] =

{ 100, 130, 239, 239, 191 };

kLengths[kNumHsps] =

{ 100, 50, 100, 9, 57 };

kSubjectOffsets[kNumHsps] =

{ 1100, 1130, 3240, 3240, 2195 };

(index = 0; index < kNumHsps; ++index) {

hsp->

= kScores[index];

m_HspList->

= kNumHsps;

kNumHsps = 8;

kScores[kNumHsps] = { 35, 31, 22, 21, 20, 20, 20, 20 };

kQueryFrames[kNumHsps] = { 1, 1, 1, -1, 1, -1, -1, -1 };

kQueryStarts[kNumHsps] =

{ 790, 790, 791, 4606, 870, 4572, 4526, 4589 };

kQueryEnds[kNumHsps] =

{ 865, 865, 833, 4635, 894, 4604, 4550, 4629 };

kSubjectStarts[kNumHsps] =

{ 453, 3469, 5837, 12508, 5951, 11005, 9899, 7397 };

kSubjectEnds[kNumHsps] =

{ 528, 3544, 5879, 12537, 5975, 11037, 9923, 7437 };

(index = 0; index < kNumHsps; ++index) {

hsp->

= kScores[index];

hsp->

.

= kQueryEnds[index];

hsp->

= (kQueryFrames[index] > 0 ? 0 : 1);

m_HspList->

= kNumHsps;

kQueryLength = 5419;

kEffDbLength = 122632232;

m_SubjectLength = 12991;

seqid(

);

pair<TSeqPos, TSeqPos> range(26993,32411);

setupScoreBlk(sequence.

.

(),

, &score_options);

fillEffectiveLengths(score_options, kEffDbLength, 1);

subj_length,

longest_intron=0)

(longest_intron > 0)

m_ProgramType, strand_opt, blast_msg);

BOOST_REQUIRE(m->empty());

setupScoreBlk(query_blk->

, gapped, &score_options);

m_QueryInfo, &ext_params);

fillEffectiveLengths(score_options, (

)db_length, db_num_seq);

BOOST_REQUIRE(score_options ==

);

m_ScoreBlk, m_QueryInfo, subj_length, 0, &m_HitParams);

BOOST_REQUIRE(query_options ==

);

avg_subj_length = (

)(db_length/db_num_seq);

m_ScoreBlk, m_QueryInfo, avg_subj_length, &word_params);

BOOST_REQUIRE(blast_seq_loc ==

);

BOOST_REQUIRE(lookup_wrap ==

);

BOOST_REQUIRE(lookup_options ==

);

testUnevenGapLinkHsps();

testUnevenGapLinkHsps();

kNumHsps = 5;

kLongestIntron = 3000;

kLinkNums[kNumHsps] = { 3, 1, 3, 1, 3 };

setupLinkHspInputTblastn();

setupHSPListForMiddleInsertTest();

setupHitParams(kLongestIntron,

);

(m_ProgramType, m_HspList, m_QueryInfo, m_SubjectLength,

m_ScoreBlk, m_HitParams->link_hsp_params,

);

(

index = 0; index < m_HspList->hspcnt; ++index) {

BOOST_REQUIRE_EQUAL(kLinkNums[index],

m_HspList->hsp_array[index]->num);

kNumHsps = 5;

kNumsLinked[kNumHsps] = { 1, 2, 2, 1, 1 };

kScores[kNumHsps] = { 1023, 282, 246, 202, 142 };

setupLinkHspInputTblastn();

setupHSPListTransl();

(m_ProgramType, m_HspList, m_QueryInfo, m_SubjectLength,

m_ScoreBlk, m_HitParams->link_hsp_params,

);

BOOST_REQUIRE_EQUAL(kNumHsps, m_HspList->hspcnt);

(index = 0; index < kNumHsps; ++index) {

BOOST_REQUIRE_EQUAL(kNumsLinked[index], m_HspList->hsp_array[index]->num);

BOOST_REQUIRE_EQUAL(kScores[index],

m_HspList->hsp_array[index]->score);

kNumHsps = 8;

kNumsLinked[kNumHsps] =

{ 2, 1, 1, 3, 2, 1, 3, 3 };

kEvalues[kNumHsps] =

{ 3e-12, 3e-7, 0.07, 1e-7, 3e-12, 1.1, 1e-7, 1e-7 };

setupLinkHspInputBlastn();

(m_ProgramType, m_HspList, m_QueryInfo, m_SubjectLength,

m_ScoreBlk, m_HitParams->link_hsp_params,

);

BOOST_REQUIRE_EQUAL(kNumHsps, m_HspList->hspcnt);

(

index = 0; index < kNumHsps; ++index) {

BOOST_REQUIRE_EQUAL(kNumsLinked[index],

m_HspList->hsp_array[index]->num);

BOOST_REQUIRE(

(kEvalues[index] - m_HspList->hsp_array[index]->evalue)/kEvalues[index] < 0.5);

kNumDbs = 4;

kDbLengths[kNumDbs] =

{ 10000000000LL, 10000000000LL, 3000000000LL, 10000LL };

kDbNumSeqs[kNumDbs] = { 2000000, 20000000, 500, 100 };

kSubjectLengths[kNumDbs] = { 2000, 400, 3000000, 100 };

{ 11, 0, 0, 0, 14, 20,

, 14, 0 },

{ 11, 0, 0, 0, 12, 20,

, 12, 0 },

{ 11, 0, 0, 0, 19, 19,

, 19, 0 },

{ 11, 0, 0, 0, 10, 10,

, 10, 0 } };

(index = 0; index < kNumDbs; ++index) {

cutoffs = setupCutoffScores(

, kDbLengths[index],

kDbNumSeqs[index], kSubjectLengths[index]);

(index < kNumDbs-1)

kDbLength = 500000000;

kDbNumSeqs = 1000000;

kNumSubjects = 3;

kSubjectLengths[kNumSubjects] = {400, 60, 3000 };

{ 16, 0, 0, 0, 41, 66,

, 41, 38 },

{ 16, 0, 0, 0, 41, 66,

, 0, 29 },

{ 16, 0, 0, 0, 41, 66,

, 41, 44 } };

(index = 0; index < kNumSubjects; ++index) {

cutoffs = setupCutoffScores(

, kDbLength,

kDbNumSeqs, kSubjectLengths[index]);

(index < kNumSubjects-1)

kDbLength =

227102922;

kDbNumSeqs =

761886;

kNumSubjects = 3;

kSubjectLengths[kNumSubjects] = { 400, 100, 3000 };

{ 16, 0, 0, 0, 31, 63,

, 31, 37 },

{ 16, 0, 0, 0, 31, 63,

, 0, 31 },

{ 16, 0, 0, 0, 31, 63,

, 31, 43 } };

(index = 0; index < kNumSubjects; ++index) {

cutoffs = setupCutoffScores(

, kDbLength, kDbNumSeqs,

kSubjectLengths[index]);

(index < kNumSubjects-1)

kNumDbs = 3;

kDbLengths[kNumDbs] =

{ 10000000000LL, 10000000000LL, 3000000000LL };

kDbNumSeqs[kNumDbs] = { 2000000, 20000000, 500 };

kSubjectLengths[kNumDbs] = { 2000, 400, 3000000 };

{ 16, 0, 0, 0, 40, 72,

, 40, 40 },

{ 16, 0, 0, 0, 33, 71,

, 33, 35 },

{ 16, 0, 0, 0, 41, 69,

, 41, 60 } };

(index = 0; index < kNumDbs; ++index) {

cutoffs = setupCutoffScores(

, kDbLengths[index],

kDbNumSeqs[index], kSubjectLengths[index]);

(index < kNumDbs-1)

kNumDbs = 4;

kDbLengths[kNumDbs] =

{ 10000000000LL, 10000000000LL, 10000000000LL, 3000000000LL };

kDbNumSeqs[kNumDbs] = { 2000000, 2000000, 20000000, 500 };

kSubjectLengths[kNumDbs] = { 2000, 100, 400, 3000000 };

{ 16, 0, 0, 0, 41, 72,

, 41, 40 },

{ 16, 0, 0, 0, 41, 72,

, 0, 27 },

{ 16, 0, 0, 0, 41, 70,

, 41, 34 },

{ 16, 0, 0, 0, 41, 68,

, 41, 60 } };

(index = 0; index < kNumDbs; ++index) {

cutoffs = setupCutoffScores(

, kDbLengths[index],

kDbNumSeqs[index], kSubjectLengths[index]);

(index < kNumDbs-1)

kNumDbs = 4;

kDbLengths[kNumDbs] =

{ 10000000000LL, 10000000000LL, 3000000000LL, 10000LL };

kDbNumSeqs[kNumDbs] = { 2000000, 20000000, 500, 200 };

kSubjectLengths[kNumDbs] = { 2000, 400, 3000000, 60 };

{ 11, 15, 50, 0, 13, 20,

, 0, 0 },

{ 11, 15, 50, 0, 13, 20,

, 0, 0 },

{ 11, 15, 50, 0, 13, 19,

, 0, 0 },

{ 11, 15, 50, 0, 10, 10,

, 0, 0 } };

(index = 0; index < kNumDbs; ++index) {

cutoffs = setupCutoffScores(

, kDbLengths[index],

kDbNumSeqs[index], kSubjectLengths[index]);

(index < kNumDbs-1)

kDbLength = 600000000;

kDbNumSeqs = 1800000;

kSubjectLength = 200;

{ 16, 38, 64, 41, 19, 19,

, 0, 0 };

setupCutoffScores(

, kDbLength, kDbNumSeqs, kSubjectLength);

kNumDbs = 2;

kDbLengths[kNumDbs] =

{600000000, 6000000000LL};

kDbNumSeqs = 1800000;

kSubjectLength[kNumDbs] = {500, 2000};

{ 16, 38, 64, 0, 22, 22,

, 22, 0 },

{ 16, 38, 64, 0, 27, 27,

, 27, 0 } };

(

index = 0; index < kNumDbs; ++index) {

kDbLengths[index], kDbNumSeqs, kSubjectLength[index]);

(index < kNumDbs-1)

kNumDbs = 3;

kDbLengths[kNumDbs] =

{ 10000000000LL, 10000000000LL, 3000000000LL };

kDbNumSeqs[kNumDbs] = { 2000000, 20000000, 500 };

kSubjectLengths[kNumDbs] = { 2000, 400, 3000000 };

{ 16, 38, 64, 41, 27, 27,

, 27, 0 },

{ 16, 38, 64, 41, 21, 21,

, 21, 0 },

{ 16, 38, 64, 41, 41, 54,

, 41, 0 } };

(index = 0; index < kNumDbs; ++index) {

cutoffs = setupCutoffScores(

, kDbLengths[index],

kDbNumSeqs[index], kSubjectLengths[index]);

(index < kNumDbs-1)

kNumDbs = 3;

kDbLengths[kNumDbs] =

{ 10000000000LL, 10000000000LL, 3000000000LL };

kDbNumSeqs[kNumDbs] = { 2000000, 20000000, 500 };

kSubjectLengths[kNumDbs] = { 2000, 400, 3000000 };

(index = 0; index < kNumDbs; ++index) {

cutoffs = setupCutoffScores(

, kDbLengths[index],

kDbNumSeqs[index], kSubjectLengths[index], 1);

BOOST_REQUIRE_EQUAL((

)

, (

) cutoffs->

);

(index < kNumDbs-1)

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

BlastSeqLoc * BlastSeqLocFree(BlastSeqLoc *loc)

Deallocate all BlastSeqLoc objects in a chain.

BlastSeqLoc * BlastSeqLocNew(BlastSeqLoc **head, Int4 from, Int4 to)

Create and initialize a new sequence interval.

Structures and API used for saving BLAST hits.

BlastHSPList * Blast_HSPListNew(Int4 hsp_max)

Creates HSP list structure with a default size HSP array.

BlastHSPList * Blast_HSPListFree(BlastHSPList *hsp_list)

Deallocate memory for an HSP list structure as well as all it's components.

Int2 Blast_HSPListReapByEvalue(BlastHSPList *hsp_list, const BlastHitSavingOptions *hit_options)

Discard the HSPs above the e-value threshold from the HSP list.

Blast_Message * Blast_MessageFree(Blast_Message *blast_msg)

Deallocates message memory.

Definitions which are dependant on the NCBI C++ Object Manager.

The structures and functions in blast_options.

#define BLAST_GAP_X_DROPOFF_NUCL

default dropoff for non-greedy nucleotide gapped extensions

BlastHitSavingOptions * BlastHitSavingOptionsFree(BlastHitSavingOptions *options)

Deallocate memory for BlastHitSavingOptions.

#define BLAST_UNGAPPED_X_DROPOFF_NUCL

ungapped dropoff score for blastn (and megablast)

Int2 BlastQuerySetUpOptionsNew(QuerySetUpOptions **options)

Allocate memory for QuerySetUpOptions and fill with default values.

Int2 BlastEffectiveLengthsOptionsNew(BlastEffectiveLengthsOptions **options)

Allocate memory for BlastEffectiveLengthsOptions* and fill with default values.

BlastInitialWordOptions * BlastInitialWordOptionsFree(BlastInitialWordOptions *options)

Deallocate memory for BlastInitialWordOptions.

Int2 BlastScoringOptionsNew(EBlastProgramType program, BlastScoringOptions **options)

Allocate memory for BlastScoringOptions and fill with default values.

BlastEffectiveLengthsOptions * BlastEffectiveLengthsOptionsFree(BlastEffectiveLengthsOptions *options)

Deallocate memory for BlastEffectiveLengthsOptions*.

Int2 LookupTableOptionsNew(EBlastProgramType program, LookupTableOptions **options)

Allocate memory for lookup table options and fill with default values.

#define BLAST_GAP_X_DROPOFF_FINAL_NUCL

default dropoff for nucleotide gapped extensions)

BlastExtensionOptions * BlastExtensionOptionsFree(BlastExtensionOptions *options)

Deallocate memory for BlastExtensionOptions.

Int2 BlastHitSavingOptionsNew(EBlastProgramType program, BlastHitSavingOptions **options, Boolean gapped_calculation)

Allocate memory for BlastHitSavingOptions.

Int2 BlastInitialWordOptionsNew(EBlastProgramType program, BlastInitialWordOptions **options)

Allocate memory for BlastInitialWordOptions and fill with default values.

BlastScoringOptions * BlastScoringOptionsFree(BlastScoringOptions *options)

Deallocate memory for BlastScoringOptions.

LookupTableOptions * LookupTableOptionsFree(LookupTableOptions *options)

Deallocates memory for LookupTableOptions*.

QuerySetUpOptions * BlastQuerySetUpOptionsFree(QuerySetUpOptions *options)

Deallocate memory for QuerySetUpOptions.

Int2 BlastExtensionOptionsNew(EBlastProgramType program, BlastExtensionOptions **options, Boolean gapped)

Allocate memory for BlastExtensionOptions and fill with default values.

Declares class to encapsulate all BLAST options.

BlastHitSavingParameters * BlastHitSavingParametersFree(BlastHitSavingParameters *parameters)

Deallocate memory for BlastHitSavingOptions*.

Int2 BlastLinkHSPParametersNew(EBlastProgramType program_number, Boolean gapped_calculation, BlastLinkHSPParameters **link_hsp_params)

Initialize the linking HSPs parameters with default values.

BlastEffectiveLengthsParameters * BlastEffectiveLengthsParametersFree(BlastEffectiveLengthsParameters *parameters)

Deallocate memory for BlastEffectiveLengthsParameters*.

Int2 BlastExtensionParametersNew(EBlastProgramType blast_program, const BlastExtensionOptions *options, BlastScoreBlk *sbp, BlastQueryInfo *query_info, BlastExtensionParameters **parameters)

Calculate the raw values for the X-dropoff parameters.

BlastInitialWordParameters * BlastInitialWordParametersFree(BlastInitialWordParameters *parameters)

Deallocate memory for BlastInitialWordParameters.

BlastExtensionParameters * BlastExtensionParametersFree(BlastExtensionParameters *parameters)

Deallocate memory for BlastExtensionParameters.

Int2 BlastInitialWordParametersNew(EBlastProgramType program_number, const BlastInitialWordOptions *word_options, const BlastHitSavingParameters *hit_params, const LookupTableWrap *lookup_wrap, const BlastScoreBlk *sbp, BlastQueryInfo *query_info, Uint4 subject_length, BlastInitialWordParameters **parameters)

Allocate memory for BlastInitialWordParameters and set x_dropoff.

Int2 BlastHitSavingParametersNew(EBlastProgramType program_number, const BlastHitSavingOptions *options, const BlastScoreBlk *sbp, const BlastQueryInfo *query_info, Int4 avg_subject_length, Int4 compositionBasedStats, BlastHitSavingParameters **parameters)

Allocate memory and initialize the BlastHitSavingParameters structure.

Int2 BlastLinkHSPParametersUpdate(const BlastInitialWordParameters *word_params, const BlastHitSavingParameters *hit_params, Boolean gapped_calculation)

Update BlastLinkHSPParameters, using calculated values of other parameters.

void CalculateLinkHSPCutoffs(EBlastProgramType program, BlastQueryInfo *query_info, const BlastScoreBlk *sbp, BlastLinkHSPParameters *link_hsp_params, const BlastInitialWordParameters *word_params, Int8 db_length, Int4 subject_length)

Calculates cutoff scores and returns them.

Int2 BlastEffectiveLengthsParametersNew(const BlastEffectiveLengthsOptions *options, Int8 db_length, Int4 num_seqs, BlastEffectiveLengthsParameters **parameters)

Allocate memory for BlastEffectiveLengthsParameters.

EBlastProgramType

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

BlastQueryInfo * BlastQueryInfoFree(BlastQueryInfo *query_info)

Deallocate memory for query information structure.

BlastQueryInfo * BlastQueryInfoNew(EBlastProgramType program, int num_queries)

Allocate memory for query information structure.

Utilities initialize/setup BLAST.

Int2 Blast_ScoreBlkKbpGappedCalc(BlastScoreBlk *sbp, const BlastScoringOptions *scoring_options, EBlastProgramType program, const BlastQueryInfo *query_info, Blast_Message **error_return)

Blast_ScoreBlkKbpGappedCalc, fills the ScoreBlkPtr for a gapped search.

Int2 Blast_ScoreBlkMatrixInit(EBlastProgramType program_number, const BlastScoringOptions *scoring_options, BlastScoreBlk *sbp, GET_MATRIX_PATH get_path)

Initializes the substitution matrix in the BlastScoreBlk according to the scoring options specified.

Int2 BLAST_CalcEffLengths(EBlastProgramType program_number, const BlastScoringOptions *scoring_options, const BlastEffectiveLengthsParameters *eff_len_params, const BlastScoreBlk *sbp, BlastQueryInfo *query_info, Blast_Message **blast_message)

Function to calculate effective query length and db length as well as effective search space.

BlastScoreBlk * BlastScoreBlkFree(BlastScoreBlk *sbp)

Deallocates BlastScoreBlk as well as all associated structures.

Int2 Blast_ScoreBlkKbpUngappedCalc(EBlastProgramType program, BlastScoreBlk *sbp, Uint1 *query, const BlastQueryInfo *query_info, Blast_Message **blast_message)

Calculate and fill the ungapped Karlin-Altschul parameters in the BlastScoreBlk structure (fields kbp...

BlastScoreBlk * BlastScoreBlkNew(Uint1 alphabet, Int4 number_of_contexts)

Allocates and initializes BlastScoreBlk.

EProgram

This enumeration is to evolve into a task/program specific list that specifies sets of default parame...

@ eTblastx

Translated nucl-Translated nucl.

@ eBlastn

Nucl-Nucl (traditional blastn)

@ eBlastp

Protein-Protein.

@ eTblastn

Protein-Translated nucl.

@ eBlastx

Translated nucl-Protein.

BOOST_AUTO_TEST_SUITE_END() static int s_GetSegmentFlags(const CBioseq &bioseq)

Wrapper class for BLAST_SequenceBlk .

Encapsulates ALL the BLAST algorithm's options.

Wrapper class for BlastQueryInfo .

static CTestObjMgr & Instance()

typedef for the messages for an entire BLAST search, which could be comprised of multiple query seque...

void SetStrandOption(objects::ENa_strand s)

void SetQueryGeneticCode(int gc)

void SetupQueries(TSeqLocVector &queries, BlastQueryInfo *qinfo, BLAST_SequenceBlk **seqblk, EBlastProgramType prog, objects::ENa_strand strand_opt, TSearchMessages &messages)

Populates BLAST_SequenceBlk with sequence data for use in CORE BLAST.

objects::ENa_strand GetStrandOption() const

#define BLASTNA_SEQ_CODE

Identifies the blastna alphabet, for use in blast only.

void SetProgram(EProgram p)

Sets the task this object is best suited for.

#define BLASTAA_SEQ_CODE

== Seq_code_ncbistdaa

TAutoUint1Ptr data

Sequence data.

char * BlastFindMatrixPath(const char *matrix_name, Boolean is_prot)

Returns the path to a specified matrix.

void SetupQueryInfo(TSeqLocVector &queries, EBlastProgramType prog, objects::ENa_strand strand_opt, BlastQueryInfo **qinfo)

Allocates the query information structure and fills the context offsets, in case of multiple queries,...

SBlastSequence GetSequence(const objects::CSeq_loc &sl, EBlastEncoding encoding, objects::CScope *scope, objects::ENa_strand strand=objects::eNa_strand_plus, ESentinelType sentinel=eSentinels, std::string *warnings=NULL)

Retrieves a sequence using the object manager.

@ eBlastEncodingNucleotide

Special encoding for preliminary stage of BLAST: permutation of NCBI4na.

@ eSentinels

Use sentinel bytes.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

element_type * get(void) const

Get pointer.

void Reset(void)

Reset reference object.

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

int64_t Int8

8-byte (64-bit) signed integer

ENa_strand

strand of nucleic acid

@ eNa_strand_both

in forward orientation

Functions to link HSPs using sum statistics.

Int2 BLAST_LinkHsps(EBlastProgramType program_number, BlastHSPList *hsp_list, const BlastQueryInfo *query_info, Int4 subject_length, const BlastScoreBlk *sbp, const BlastLinkHSPParameters *link_hsp_params, Boolean gapped_calculation)

Link HSPs using sum statistics.

BOOST_AUTO_TEST_CASE(testUnevenGapLinkHspsTblastn)

Test linking with uneven gap sum statistics.

static void s_SetupNuclQueryInfo(Uint4 query_length, BlastQueryInfo **query_info)

Sets up the query information structure without a real sequence.

static void testAllCutoffs(const AllCutoffScores &good_cutoffs, AllCutoffScores &cutoffs)

LookupTableWrap * LookupTableWrapFree(LookupTableWrap *lookup)

Deallocate memory for the lookup table.

Int2 LookupTableWrapInit(BLAST_SequenceBlk *query, const LookupTableOptions *lookup_options, const QuerySetUpOptions *query_options, BlastSeqLoc *lookup_segments, BlastScoreBlk *sbp, LookupTableWrap **lookup_wrap_ptr, const BlastRPSInfo *rps_info, Blast_Message **error_msg, BlastSeqSrc *seqsrc)

Create the lookup table for all query words.

Magic spell ;-) needed for some weird compilers... very empiric.

int strcmp(const char *str1, const char *str2)

Uint1 Boolean

bool replacment for C

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

Defines: CTimeFormat - storage class for time format.

Implementation of the BlastSeqSrc interface using the C++ BLAST databases API.

static const char * kEvalue

vector< SSeqLoc > TSeqLocVector

Vector of sequence locations.

Int4 cutoff_score_ungapped

Uint1 * sequence

Sequence used for search (could be translation).

Int4 query_length

Length of this query, strand or frame.

Options for setting up effective lengths and search spaces.

Parameters for setting up effective lengths and search spaces.

Options used for gapped extension These include: a.

double gap_x_dropoff_final

X-dropoff value for the final gapped extension (in bits)

double gap_x_dropoff

X-dropoff value for gapped extension (in bits)

Computed values used as parameters for gapped alignments.

Int4 gap_x_dropoff_final

X-dropoff value for the final gapped extension (raw)

Int4 gap_x_dropoff

X-dropoff value for gapped extension (raw)

The structure to hold all HSPs for a given sequence after the gapped alignment.

Int4 hspcnt

Number of HSPs saved.

BlastHSP ** hsp_array

Array of pointers to individual HSPs.

Structure holding all information about an HSP.

BlastSeg query

Query sequence info.

Int4 context

Context number of query.

Int4 num

How many HSP's are linked together for sum statistics evaluation? If unset (0), this HSP is not part ...

BlastSeg subject

Subject sequence info.

Int4 score

This HSP's raw score.

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

Int4 longest_intron

The longest distance between HSPs allowed for combining via sum statistics with uneven gaps.

double expect_value

The expect value cut-off threshold for an HSP, or a combined hit if sum statistics is used.

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

Int4 cutoff_score_min

smallest cutoff score across all contexts

Boolean do_sum_stats

TRUE if sum stats will be used.

BlastLinkHSPParameters * link_hsp_params

Parameters for linking HSPs with sum statistics; linking is not done if NULL.

BlastHitSavingOptions * options

The original (unparsed) options.

Options needed for initial word finding and processing.

double x_dropoff

X-dropoff value (in bits) for the ungapped extension.

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

Int4 cutoff_score_min

smallest cutoff score across all contexts

Int4 x_dropoff_max

largest X-drop cutoff across all contexts

Int4 cutoff_big_gap

Cutoff sum score for linked HSPs with big gaps.

Int4 cutoff_small_gap

Cutoff sum score for linked HSPs with small gaps.

Int4 longest_intron

Length of a longest intron for uneven gap linking of HSPs.

The query related information.

BlastContextInfo * contexts

Information per context.

Int4 last_context

Index of the last element of the context array.

Structure used for scoring calculations.

Blast_KarlinBlk ** kbp

Karlin-Altschul parameters.

Blast_KarlinBlk ** kbp_gap

K-A parameters for gapped alignments.

Blast_KarlinBlk ** kbp_gap_std

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

Blast_KarlinBlk ** kbp_std

K-A parameters for ungapped alignments.

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

Boolean gapped_calculation

gap-free search if FALSE

char * matrix

Name of the matrix containing all scores: needed for finding neighboring words.

Int2 frame

Translation frame.

Int4 offset

Start of hsp.

Used to hold a set of positions, mostly used for filtering.

Structure to hold the a message from the core of the BLAST engine.

void freeStructures()

Frees all the C structures used in the test.

BlastScoreBlk * m_ScoreBlk

void fillEffectiveLengths(const BlastScoringOptions *score_options, Int8 db_length, Int4 db_num_seq)

Fills the effective lengths data into the query information structure.

void setupLinkHspInputBlastn()

Complete set-up before calling the HSP linking algorithm.

void setupScoreBlk(Uint1 *seqbuf, bool gapped, BlastScoringOptions **score_options_ptr)

Sets up the scoring block with the Karlin-Altschul parameters.

void setupLinkHspInputTblastn()

Complete set-up before calling the HSP linking algorithm.

BlastHitSavingParameters * m_HitParams

void setupHitParams(int longest_intron, double evalue)

Sets up the hit saving parameters structures.

void setupHSPListNucl()

HSP list setup for blastn.

void setupHSPListForMiddleInsertTest()

void setupHSPListTransl()

Sets up the input list of HSPs. These must be sorted by score.

AllCutoffScores * setupCutoffScores(bool gapped, Int8 db_length, Uint4 db_num_seq, Uint4 subj_length, int longest_intron=0)

CBlastQueryInfo m_QueryInfo

void testUnevenGapLinkHsps()

Test linking with uneven gap sum statistics.

EBlastProgramType m_ProgramType

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

Wrapper structure for different types of BLAST lookup tables.

Options required for setting up the query sequence.

Structure to store sequence data and its length for use in the CORE of BLAST (it's a malloc'ed array ...

Utility stuff for more convenient using of Boost.Test library.

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