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

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

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

;

query_offset[],

query_end[],

subject_offset[],

subject_end[],

query_gapped_start[],

subject_gapped_start[],

evalue[] =

,

num_ident[] =

)

kQueryContext = 0;

kSubjectFrame = 0;

kQueryFrame = 0;

(

= 0;

< num_hsps;

++) {

subject_offset[

], subject_end[

],

query_gapped_start[

],

subject_gapped_start[

],

kQueryContext, kQueryFrame, kSubjectFrame, score[

],

query_length)

ifstream

(filename.c_str());

runtime_error(filename +

);

(

= 0;

< query_length;

++) {

>> retval[

][j];

runtime_error(

+ filename);

runtime_error(

);

loadPssmFromFile(

,

effective_searchsp,

doSmithWaterman,

evalue_threshold =

effective_searchsp,

doSmithWaterman,

evalue_threshold =

effective_searchsp,

doSmithWaterman,

evalue_threshold,

runRedoAlignmentCoreUnitTest(program, *qsl, *ssl, init_hsp_list,

ending_hsp_list, effective_searchsp, compositonBasedStatsMode,

doSmithWaterman, evalue_threshold, hit_list_size);

effective_searchsp,

doSmithWaterman,

evalue_threshold,

* program_buffer =

;

BOOST_REQUIRE_MESSAGE(rv == (

)0,

);

(program_buffer);

core_prog, strand_opt,&query_info);

query_info, &query_blk, core_prog, strand_opt, blast_msg);

BOOST_REQUIRE(m->empty());

BOOST_REQUIRE(rv == 0);

BOOST_REQUIRE(rv == 0);

BOOST_REQUIRE(writer_info ==

);

k_rps_scale_factor = 1.0;

program, &sbp, k_rps_scale_factor,

setupPositionBasedBlastScoreBlk(sbp,

&effective_searchsp, 1);

eff_len_params, sbp, query_info,

);

BOOST_REQUIRE(eff_len_opts ==

);

BOOST_REQUIRE(eff_len_params ==

);

kAvgSubjLen = 0;

sbp, query_info, kAvgSubjLen,

query_info, sbp,

, seq_src,

ext_params, hit_params, psi_options,

BOOST_REQUIRE_MESSAGE(rv == (

)0,

);

BOOST_REQUIRE(hsp_stream ==

);

BOOST_REQUIRE(ext_params ==

);

BOOST_REQUIRE(ext_options ==

);

BOOST_REQUIRE(hit_params ==

);

BOOST_REQUIRE(scoring_params ==

);

BOOST_REQUIRE(psi_options ==

);

BOOST_REQUIRE(sbp ==

);

BOOST_REQUIRE(

->hitlist_array[0]->hsplist_count > 0);

BOOST_REQUIRE_EQUAL(ending_hsp_list->

, hsp_list->

);

cout <<

<< ending_hsp_list->

;

cout <<

<< hsp_list->

<< endl;

(

index=0; index<hsp_list->

; index++)

cout << index <<

cout << index <<

<< actual_hsp->

.

<< endl;

cout << index <<

cout << index <<

cout << index <<

<< actual_hsp->

<< endl;

cout << index <<

cout << index <<

<< actual_hsp->

<< endl;

cout << index <<

BOOST_REQUIRE_EQUAL(expected_hsp->

.

,

BOOST_REQUIRE_EQUAL(expected_hsp->

.

,

BOOST_REQUIRE_EQUAL(expected_hsp->

.

,

BOOST_REQUIRE_EQUAL(expected_hsp->

,

actual_hsp->

);

BOOST_REQUIRE_EQUAL(expected_hsp->

,

cerr <<

<< index <<

<< diff << endl;

BOOST_REQUIRE_CLOSE(expected_hsp->

, actual_hsp->

, 10.0);

k_num_hsps_start = 3;

k_num_hsps_end = 2;

subj_id(

);

query_offset[k_num_hsps_start] = { 28, 46, 463};

query_end[k_num_hsps_start] = { 485, 331, 488};

subject_offset[k_num_hsps_start] = { 36, 327, 320};

subject_end[k_num_hsps_start] = { 512, 604, 345};

score[k_num_hsps_start] = { 554, 280, 28};

query_gapped_start[k_num_hsps_start] = { 431, 186, 480};

subject_gapped_start[k_num_hsps_start] = { 458, 458, 337};

setUpHSPList(k_num_hsps_start,

query_offset, query_end,

subject_offset, subject_end,

subject_gapped_start,

query_offset_final[k_num_hsps_end] = { 2, 46};

query_end_final[k_num_hsps_end] = { 485, 331};

subject_offset_final[k_num_hsps_end] = { 9, 327};

subject_end_final[k_num_hsps_end] = { 512, 604};

score_final[k_num_hsps_end] = { 510, 282};

evalue_final[k_num_hsps_end] = {7.0065e-61, 1.6958e-30};

num_idents_final[k_num_hsps_end] = { 171, 94 };

setUpHSPList(k_num_hsps_end,

subject_offset_final,

subject_offset_final,

kEffSearchSp = 500000;

kSmithWaterman =

;

runRedoAlignmentCoreUnitTest(kProgram, query_id, subj_id,

init_hsp_list, ending_hsp_list,

BOOST_REQUIRE(ending_hsp_list ==

);

k_num_hsps_start = 3;

k_num_hsps_end = 2;

subj_id(

);

query_offset[k_num_hsps_start] = { 28, 46, 463};

query_end[k_num_hsps_start] = { 485, 331, 488};

subject_offset[k_num_hsps_start] = { 36, 327, 320};

subject_end[k_num_hsps_start] = { 512, 604, 345};

score[k_num_hsps_start] = { 554, 280, 28};

query_gapped_start[k_num_hsps_start] = { 431, 186, 480};

subject_gapped_start[k_num_hsps_start] = { 458, 458, 337};

setUpHSPList(k_num_hsps_start,

query_offset, query_end,

subject_offset, subject_end,

subject_gapped_start,

query_offset_final[k_num_hsps_end] = { 2, 46};

query_end_final[k_num_hsps_end] = { 517, 331};

subject_offset_final[k_num_hsps_end] = { 9, 327};

subject_end_final[k_num_hsps_end] = { 546, 604};

score_final[k_num_hsps_end] = { 537, 298};

evalue_final[k_num_hsps_end] = {1.1954e-64, 1.5494e-32};

num_idents_final[k_num_hsps_end] = { 177, 95 };

setUpHSPList(k_num_hsps_end,

subject_offset_final,

subject_offset_final,

kEffSearchSp = 500000;

kSmithWaterman =

;

runRedoAlignmentCoreUnitTest(kProgram, query_id, subj_id,

init_hsp_list, ending_hsp_list,

BOOST_REQUIRE(ending_hsp_list ==

);

k_num_hsps_start = 6;

k_num_hsps_end = 2;

query_id(

);

subj_id(

);

query_offset[k_num_hsps_start] = { 24, 99, 16, 84, 6, 223 };

query_end[k_num_hsps_start] = { 62, 128, 24, 114, 25, 231 };

subject_offset[k_num_hsps_start] =

{ 245, 0, 198, 86, 334, 151 };

subject_end[k_num_hsps_start] =

{ 287, 29, 206, 119, 353, 159 };

score[k_num_hsps_start] = { 37, 26, 25, 25, 24, 24 };

query_gapped_start[k_num_hsps_start] =

{ 29, 104, 20, 91, 19, 227 };

subject_gapped_start[k_num_hsps_start] =

{ 250, 5, 202, 93, 347, 155 };

setUpHSPList(k_num_hsps_start,

query_offset, query_end,

subject_offset, subject_end,

subject_gapped_start,

query_offset_final[k_num_hsps_end] = { 24, 18 };

query_end_final[k_num_hsps_end] = { 30, 31 };

subject_offset_final[k_num_hsps_end] = { 245, 200 };

subject_end_final[k_num_hsps_end] = { 251, 210 };

score_final[k_num_hsps_end] = { 29, 24 };

evalue_final[k_num_hsps_end] =

{ 1.361074 , 6.425098 };

ident_final[k_num_hsps_end] = { 3, 6};

setUpHSPList(k_num_hsps_end,

subject_offset_final,

subject_offset_final,

kEffSearchSp = 84660;

kSmithWaterman =

;

runRedoAlignmentCoreUnitTest(kProgram, query_id, subj_id,

init_hsp_list, ending_hsp_list,

BOOST_REQUIRE(ending_hsp_list ==

);

k_num_hsps_start = 6;

k_num_hsps_end = 5;

subj_id(

);

is_protein(

);

query_offset[k_num_hsps_start] = { 3, 1, 4, 3, 0, 1 };

query_end[k_num_hsps_start] = { 236, 232, 236, 235, 226, 233 };

subject_offset[k_num_hsps_start] =

{ 1, 1, 6, 6, 12, 22 };

subject_end[k_num_hsps_start] =

{ 238, 238, 238, 238, 238, 254 };

score[k_num_hsps_start] = { 345, 344, 343, 339, 332, 320 };

query_gapped_start[k_num_hsps_start] =

{ 32, 194, 9, 8, 104, 9 };

subject_gapped_start[k_num_hsps_start] =

{ 30, 200, 11, 11, 116, 30 };

setUpHSPList(k_num_hsps_start,

query_offset, query_end,

subject_offset, subject_end,

subject_gapped_start,

query_offset_final[k_num_hsps_end] = { 4, 3, 3, 0, 0};

query_end_final[k_num_hsps_end] = { 236, 235, 220, 226, 232};

subject_offset_final[k_num_hsps_end] = { 6, 6, 1, 12, 6};

subject_end_final[k_num_hsps_end] = { 238, 238, 218, 238, 238};

score_final[k_num_hsps_end] = { 73, 72, 69, 68, 66};

evalue_final[k_num_hsps_end] =

{ 1.26e-05 , 1.7e-5 , 4.0e-5, 5.1e-5, 0.0000775};

num_idents_final[k_num_hsps_end] = { 87, 85, 81, 84, 85 };

setUpHSPList(k_num_hsps_end,

subject_offset_final,

subject_offset_final,

kEffSearchSp = 84660;

kSmithWaterman =

;

runRedoAlignmentCoreUnitTest(kProgram, query_seqs[0], *ssl,

init_hsp_list, ending_hsp_list,

BOOST_REQUIRE(ending_hsp_list ==

);

k_num_hsps_start = 3;

k_num_hsps_end = 5;

subj_id(

);

query_offset[k_num_hsps_start] = { 28, 46, 463 };

query_end[k_num_hsps_start] = { 485, 331, 488 };

subject_offset[k_num_hsps_start] = { 36, 327, 320 };

subject_end[k_num_hsps_start] = { 512, 604, 345 };

score[k_num_hsps_start] = { 554, 280, 28 };

query_gapped_start[k_num_hsps_start] = { 431, 186, 480 };

subject_gapped_start[k_num_hsps_start] = { 458, 458, 337 };

setUpHSPList(k_num_hsps_start,

query_offset, query_end,

subject_offset, subject_end,

subject_gapped_start,

query_offset_final[k_num_hsps_end] = { 2, 250, 494, 67, 2 };

query_end_final[k_num_hsps_end] = { 485, 331, 530, 86, 24 };

subject_offset_final[k_num_hsps_end] = { 9, 523, 261, 585, 570 };

subject_end_final[k_num_hsps_end] = { 512, 604, 297, 604, 592 };

score_final[k_num_hsps_end] = { 591, 39, 37, 33, 32 };

evalue_final[k_num_hsps_end] = { 2.3451e-72, 0.387,

0.6692, 1.9988, 2.6256 };

num_idents_final[k_num_hsps_end] = { 172, 22, 9, 8, 7 };

setUpHSPList(k_num_hsps_end,

subject_offset_final,

subject_offset_final,

kEffSearchSp = 500000;

kSmithWaterman =

;

runRedoAlignmentCoreUnitTest(kProgram, query_id, subj_id,

init_hsp_list, ending_hsp_list,

BOOST_REQUIRE(ending_hsp_list ==

);

k_num_hsps_start = 3;

k_num_hsps_end = 3;

subj_id(

);

query_offset[k_num_hsps_start] = { 28, 46, 463};

query_end[k_num_hsps_start] = { 485, 331, 488};

subject_offset[k_num_hsps_start] = { 36, 327, 320};

subject_end[k_num_hsps_start] = { 512, 604, 345};

score[k_num_hsps_start] = { 554, 280, 28};

query_gapped_start[k_num_hsps_start] = { 431, 186, 480};

subject_gapped_start[k_num_hsps_start] = { 458, 458, 337};

setUpHSPList(k_num_hsps_start,

query_offset, query_end,

subject_offset, subject_end,

subject_gapped_start,

query_offset_final[k_num_hsps_end] = { 2, 250, 67 };

query_end_final[k_num_hsps_end] = { 485, 331, 86};

subject_offset_final[k_num_hsps_end] = { 9, 523, 585};

subject_end_final[k_num_hsps_end] = { 512, 604, 604};

score_final[k_num_hsps_end] = { 510, 34, 31};

evalue_final[k_num_hsps_end] = {7.0065e-61, 1.349, 3.7944};

num_idents_final[k_num_hsps_end] = { 171, 22, 8 };

setUpHSPList(k_num_hsps_end,

subject_offset_final,

subject_offset_final,

kEffSearchSp = 500000;

kSmithWaterman =

;

runRedoAlignmentCoreUnitTest(kProgram, query_id, subj_id,

init_hsp_list, ending_hsp_list,

BOOST_REQUIRE(ending_hsp_list ==

);

k_num_hsps_start = 6;

k_num_hsps_end = 8;

query_id(

);

subj_id(

);

query_offset[k_num_hsps_start] =

{ 24, 99, 16, 84, 6, 223 };

query_end[k_num_hsps_start] =

{ 62, 128, 24, 114, 25, 231 };

subject_offset[k_num_hsps_start] =

{ 245, 0, 198, 86, 334, 151 };

subject_end[k_num_hsps_start] =

{ 287, 29, 206, 119, 353, 159 };

score[k_num_hsps_start] =

{ 37, 26, 25, 25, 24, 24 };

query_gapped_start[k_num_hsps_start] =

{ 29, 104, 20, 91, 19, 227 };

subject_gapped_start[k_num_hsps_start] =

{ 250, 5, 202, 93, 347, 155 };

setUpHSPList(k_num_hsps_start,

query_offset, query_end,

subject_offset, subject_end,

subject_gapped_start,

query_offset_final[k_num_hsps_end] =

{ 24, 140, 126, 10, 137, 198, 18, 137 };

query_end_final[k_num_hsps_end] =

{ 30, 171, 205, 35, 157, 208, 31, 152 };

subject_offset_final[k_num_hsps_end] =

{ 245, 408, 212, 130, 339, 388, 200, 186 };

subject_end_final[k_num_hsps_end] =

{ 251, 439, 287, 155, 359, 398, 210, 201 };

score_final[k_num_hsps_end] =

{ 29, 28, 28, 28, 25, 24, 24, 22 };

evalue_final[k_num_hsps_end] =

{ 1.361074, 1.837947, 2.118044, 2.153685, 4.198304, 5.529096,

6.425098, 8.532644 };

ident_final[k_num_hsps_end] =

{ 3, 8, 23, 10, 6, 5, 6, 5};

setUpHSPList(k_num_hsps_end,

subject_offset_final,

subject_offset_final,

kEffSearchSp = 84660;

kSmithWaterman =

;

runRedoAlignmentCoreUnitTest(kProgram, query_id, subj_id,

init_hsp_list, ending_hsp_list,

BOOST_REQUIRE(ending_hsp_list ==

);

k_num_hsps_start = 4;

k_num_hsps_end = 4;

query_id(

);

subj_id(

);

query_offset[k_num_hsps_start] = { 995, 1004, 995, 973};

query_end[k_num_hsps_start] = { 1314, 1314, 1403, 1316};

subject_offset[k_num_hsps_start] = { 61, 36, 61, 106};

subject_end[k_num_hsps_start] = { 384, 384, 455, 420};

score[k_num_hsps_start] = { 341, 327, 314, 301};

query_gapped_start[k_num_hsps_start] = { 1233, 1017, 1310,

subject_gapped_start[k_num_hsps_start] = { 303, 49, 347, 331};

setUpHSPList(k_num_hsps_start,

query_offset, query_end,

subject_offset, subject_end,

subject_gapped_start,

query_offset_final[k_num_hsps_end] =

{ 995, 1261, 1025, 1210};

query_end_final[k_num_hsps_end] =

{ 1314, 1341, 1125, 1243};

subject_offset_final[k_num_hsps_end] =

subject_end_final[k_num_hsps_end] =

{ 384, 115, 482, 50};

score_final[k_num_hsps_end] =

evalue_final[k_num_hsps_end] =

{ 2.712e-34, 3.6003e-05, 0.00048334, 0.00441};

num_idents_final[k_num_hsps_end] = { 108, 31, 30, 12 };

setUpHSPList(k_num_hsps_end,

subject_offset_final,

subject_offset_final,

kEffSearchSp = 1000*1000;

kSmithWaterman =

;

kHitListSize = 1;

kEvalueThreshold = 0.005;

runRedoAlignmentCoreUnitTest(kProgram, query_id, subj_id,

init_hsp_list, ending_hsp_list,

kSmithWaterman, kEvalueThreshold,

BOOST_REQUIRE(ending_hsp_list ==

);

Declares the CBl2Seq (BLAST 2 Sequences) class.

#define sfree(x)

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

Interface for reading SRA sequences into blast input.

Structures and API used for saving BLAST hits.

BlastHSPResults * Blast_HSPResultsFree(BlastHSPResults *results)

Deallocate memory for BLAST results.

Int2 Blast_HSPInit(Int4 query_start, Int4 query_end, Int4 subject_start, Int4 subject_end, Int4 query_gapped_start, Int4 subject_gapped_start, Int4 query_context, Int2 query_frame, Int2 subject_frame, Int4 score, GapEditScript **gap_edit, BlastHSP **ret_hsp)

Allocates BlastHSP and inits with information from input.

BlastHSPList * Blast_HSPListNew(Int4 hsp_max)

Creates HSP list structure with a default size HSP array.

BlastHSPResults * Blast_HSPResultsNew(Int4 num_queries)

Initialize the results structure.

Int2 Blast_HSPListSaveHSP(BlastHSPList *hsp_list, BlastHSP *hsp)

Saves HSP information into a BlastHSPList structure.

BlastHSPList * Blast_HSPListFree(BlastHSPList *hsp_list)

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

void Blast_HSPListSortByScore(BlastHSPList *hsp_list)

Sort the HSPs in an HSP list by score.

BlastHSPWriter * BlastHSPWriterNew(BlastHSPWriterInfo **writer_info, BlastQueryInfo *query_info, BLAST_SequenceBlk *query)

A generic function to create writer.

Declaration of ADT to save and retrieve lists of HSPs in the BLAST engine.

int BlastHSPStreamWrite(BlastHSPStream *hsp_stream, BlastHSPList **hsp_list)

Invokes the user-specified write function for this BlastHSPStream implementation.

BlastHSPStream * BlastHSPStreamFree(BlastHSPStream *hsp_stream)

Frees the BlastHSPStream structure by invoking the destructor function set by the user-defined constr...

BlastHSPStream * BlastHSPStreamNew(EBlastProgramType program, const BlastExtensionOptions *extn_opts, Boolean sort_on_read, Int4 num_queries, BlastHSPWriter *writer)

Initialize the HSP stream.

Interface for converting sources of sequence data into blast sequence input.

Header file for composition-based statistics.

Int2 Blast_RedoAlignmentCore(EBlastProgramType program_number, BLAST_SequenceBlk *queryBlk, const BlastQueryInfo *query_info, BlastScoreBlk *sbp, BLAST_SequenceBlk *subjectBlk, const BlastSeqSrc *seqSrc, Int4 db_genetic_code, BlastHSPList *thisMatch, BlastHSPStream *hsp_stream, BlastScoringParameters *scoringParams, const BlastExtensionParameters *extendParams, const BlastHitSavingParameters *hitParams, const PSIBlastOptions *psiOptions, BlastHSPResults *results)

Top level routine to recompute alignments for each match found by the gapped BLAST algorithm (single-...

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

PSIBlastOptions * PSIBlastOptionsFree(PSIBlastOptions *psi_options)

Deallocate PSI BLAST options.

#define BLAST_HITLIST_SIZE

Number of database sequences to save hits for.

Int2 BlastEffectiveLengthsOptionsNew(BlastEffectiveLengthsOptions **options)

Allocate memory for BlastEffectiveLengthsOptions* and fill with default values.

Int2 BLAST_FillEffectiveLengthsOptions(BlastEffectiveLengthsOptions *options, Int4 dbseq_num, Int8 db_length, Int8 *searchsp_eff, Int4 num_searchsp)

Fill the non-default values in the BlastEffectiveLengthsOptions structure.

Int2 BlastScoringOptionsNew(EBlastProgramType program, BlastScoringOptions **options)

Allocate memory for BlastScoringOptions and fill with default values.

BlastEffectiveLengthsOptions * BlastEffectiveLengthsOptionsFree(BlastEffectiveLengthsOptions *options)

Deallocate memory for BlastEffectiveLengthsOptions*.

BlastExtensionOptions * BlastExtensionOptionsFree(BlastExtensionOptions *options)

Deallocate memory for BlastExtensionOptions.

#define BLAST_EXPECT_VALUE

Default parameters for saving hits.

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

Allocate memory for BlastHitSavingOptions.

@ eSmithWatermanTbck

Smith-waterman finds optimal scores, then ALIGN_EX to find alignment.

Int2 PSIBlastOptionsNew(PSIBlastOptions **psi_options)

Initialize default options for PSI BLAST.

#define BLAST_GENETIC_CODE

Default genetic code for query and/or database.

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

Allocate memory for BlastExtensionOptions and fill with default values.

Declares the CBlastOptionsHandle and CBlastOptionsFactory classes.

BlastHitSavingParameters * BlastHitSavingParametersFree(BlastHitSavingParameters *parameters)

Deallocate memory for BlastHitSavingOptions*.

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.

BlastExtensionParameters * BlastExtensionParametersFree(BlastExtensionParameters *parameters)

Deallocate memory for BlastExtensionParameters.

Int2 BlastScoringParametersNew(const BlastScoringOptions *options, BlastScoreBlk *sbp, BlastScoringParameters **parameters)

Calculate scaled cutoff scores and gap penalties.

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.

BlastScoringParameters * BlastScoringParametersFree(BlastScoringParameters *parameters)

Deallocate memory for BlastScoringParameters.

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.

Declares the CBlastProteinOptionsHandle class.

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

Generic 2 dimensional matrix allocator.

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

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

Utilities initialize/setup BLAST.

Int2 BlastSetup_ScoreBlkInit(BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info, const BlastScoringOptions *scoring_options, EBlastProgramType program_number, BlastScoreBlk **sbpp, double scale_factor, Blast_Message **blast_message, GET_MATRIX_PATH get_path)

Initializes the score block structure.

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.

SPsiBlastScoreMatrix * SPsiBlastScoreMatrixNew(size_t ncols)

Allocates a new SPsiBlastScoreMatrix structure of dimensions ncols by BLASTAA_SIZE.

EProgram

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

Int2 BlastNumber2Program(EBlastProgramType number, char **program)

Return string name for program given a number.

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

Wrapper class for BLAST_SequenceBlk .

Runs the BLAST algorithm between 2 sequences.

Wrapper class for BlastExtensionOptions .

Class representing a text file containing sequences in fasta format.

Wrapper class for BlastHitSavingOptions .

Class that centralizes the configuration data for sequences to be converted.

Generalized converter from an abstract source of biological sequence data to collections of blast inp...

Encapsulates ALL the BLAST algorithm's options.

Wrapper class for BlastQueryInfo .

Class whose purpose is to create CScope objects which have data loaders added with different prioriti...

CRef< objects::CScope > NewScope()

Create a new, properly configured CScope.

Wrapper class for BlastScoringOptions .

Wrapper class for BlastSeqSrc .

static CTestObjMgr & Instance()

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

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.

@ eNoCompositionBasedStats

Don't use composition based statistics.

@ eCompositionMatrixAdjust

Composition-based score adjustment as in Bioinformatics 21:902-911, 2005, conditioned on sequence pro...

const CBlastOptionsHandle & GetOptionsHandle() const

Retrieve the options handle.

#define BLASTAA_SIZE

Size of aminoacid alphabet.

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

BlastSeqSrc * MultiSeqBlastSeqSrcInit(TSeqLocVector &seq_vector, EBlastProgramType program, bool dbscan_mode=false)

Initialize the sequence source structure.

EBlastProgramType GetProgramType() const

Returns the CORE BLAST notion of program type.

const CBlastOptions & GetOptions() const

Return the object which this object is a handle for.

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

Returns the path to a specified matrix.

const TSeqLocVector & GetQueries() const

Retrieve a vector of query sequences.

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

EProgram ProgramNameToEnum(const std::string &program_name)

Map a string into an element of the ncbi::blast::EProgram enumeration (except eBlastProgramMax).

const TSeqLocVector & GetSubjects() const

Retrieve a vector of subject sequences.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

TSeqPos GetLength(const CSeq_id &id, CScope *scope)

Get sequence length if scope not null, else return max possible TSeqPos.

int16_t Int2

2-byte (16-bit) signed integer

int64_t Int8

8-byte (64-bit) signed integer

IO_PREFIX::ifstream CNcbiIfstream

Portable alias for ifstream.

ENa_strand

strand of nucleic acid

Implementation of a number of BlastHSPWriters to save hits from a BLAST search, and subsequently retu...

BlastHSPCollectorParams * BlastHSPCollectorParamsNew(const BlastHitSavingOptions *hit_options, Int4 compositionBasedStats, Boolean gapped_calculation)

Sets up parameter set for use by collector.

BlastHSPWriterInfo * BlastHSPCollectorInfoNew(BlastHSPCollectorParams *params)

WriterInfo to create a default writer: the collecter.

Definitions used to get joint probabilities for a scoring matrix.

int Blast_FrequencyDataIsAvailable(const char *matrix_name)

Retrieve the background letter probabilities implicitly used in constructing the score matrix matrix_...

void CheckForBlastSeqSrcErrors(const BlastSeqSrc *seqsrc)

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

#define FALSE

bool replacment for C indicating false.

Defines: CTimeFormat - storage class for time format.

std::istream & in(std::istream &in_, double &x_)

BOOST_AUTO_TEST_CASE(testRedoAlignmentWithCompBasedStats)

Implementation of the BlastSeqSrc interface for a vector of sequence locations.

vector< SSeqLoc > TSeqLocVector

Vector of sequence locations.

Int8 eff_searchsp

Effective search space for this context.

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.

EBlastTbackExt eTbackExt

type of traceback extension.

Int4 compositionBasedStats

mode of compositional adjustment to use; if zero then compositional adjustment is not used

Computed values used as parameters for gapped alignments.

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.

The structure to contain all BLAST results, for multiple queries.

Default implementation of BlastHSPStream.

A wrap of data structure used to create a writer.

ADT definition of BlastHSPWriter.

Structure holding all information about an HSP.

double evalue

This HSP's e-value.

Int4 num_ident

Number of identical base pairs in this HSP.

BlastSeg query

Query sequence info.

double bit_score

Bit score, calculated from score.

BlastSeg subject

Subject sequence info.

Int4 score

This HSP's raw score.

double expect_value

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

Int4 hitlist_size

Maximal number of database sequences to return results for.

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

BlastContextInfo * contexts

Information per context.

int num_queries

Number of query sequences.

Structure used for scoring calculations.

Blast_KarlinBlk ** kbp

Karlin-Altschul parameters.

Blast_KarlinBlk ** kbp_psi

K-A parameters for position-based alignments.

Blast_KarlinBlk ** kbp_gap

K-A parameters for gapped alignments.

SPsiBlastScoreMatrix * psi_matrix

PSSM and associated data.

Blast_KarlinBlk ** kbp_gap_psi

K-A parameters for psi alignments.

Boolean gapped_calculation

gap-free search if FALSE

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

Int4 offset

Start of hsp.

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

static int ** loadPssmFromFile(const string &filename, unsigned int query_length)

CRedoAlignmentTestFixture()

static BlastHSPList * setUpHSPList(int num_hsps, const int query_offset[], const int query_end[], const int subject_offset[], const int subject_end[], const int query_gapped_start[], const int subject_gapped_start[], const int score[], const double evalue[]=NULL, const int num_ident[]=NULL)

~CRedoAlignmentTestFixture()

static void runRedoAlignmentCoreUnitTest(EBlastProgramType program, CSeq_id &qid, CSeq_id &sid, BlastHSPList *init_hsp_list, const BlastHSPList *ending_hsp_list, Int8 effective_searchsp, ECompoAdjustModes compositonBasedStatsMode, bool doSmithWaterman, double evalue_threshold=BLAST_EXPECT_VALUE, int hit_list_size=BLAST_HITLIST_SIZE)

static void setupPositionBasedBlastScoreBlk(BlastScoreBlk *sbp, unsigned int qlen)

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

int ** data

actual scoring matrix data, stored in row-major form

SBlastScoreMatrix * pssm

position-specific score matrix

Structure to represent a single sequence to be fed to BLAST.

CConstRef< objects::CSeq_loc > seqloc

Seq-loc describing the sequence to use as query/subject to BLAST The types of Seq-loc currently suppo...

CRef< objects::CScope > scope

Scope where the sequence referenced can be found by the toolkit's object manager.

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

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