RetroSearch Browse

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

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

NCBI C++ ToolKit: src/algo/structure/struct_dp/block_align.cpp Source File

49 #define ERROR_MESSAGE(s) ERR_POST(Error << "block_align: "

<< s << '!')

50 #define WARNING_MESSAGE(s) ERR_POST(Warning << "block_align: "

<< s)

51 #define INFO_MESSAGE(s) ERR_POST(Info << "block_align: "

<< s)

53 #define NO_TRACEBACK kMax_UInt 67 typedef

vector < ResidueRow >

Grid

;

69 Matrix

(

unsigned int

nBlocks,

unsigned int

nResidues) :

grid

(nBlocks + 1)

70

{

for

(

unsigned int i

=0;

<nBlocks; ++

)

grid

[

resize

(nResidues + 1); }

77 unsigned int

queryFrom,

unsigned int

queryTo,

bool

checkGapSum)

82

unfrozenBlocksLength = 0,

83

prevFrozenBlock =

NONE

100 ERROR_MESSAGE

(

"Frozen block "

<< (block+1) <<

" can't start < "

<< (queryFrom+1));

104 ERROR_MESSAGE

(

"Frozen block "

<< (block+1) <<

" can't end > "

<< (queryTo+1));

109 if

(prevFrozenBlock !=

NONE

) {

110 unsigned int

prevFrozenBlockEnd =

115 ERROR_MESSAGE

(

"Frozen block "

<< (block+1) <<

" starts before end of prior frozen block, " 116 "or doesn't leave room for intervening unfrozen block(s)"

);

123 blocks

freezeBlocks

[block] > prevFrozenBlockEnd + 1 + unfrozenBlocksLength + maxGapsLength)

125 if

(prevFrozenBlock == block - 1) {

126 WARNING_MESSAGE

(

"Frozen block "

<< (block+1) <<

" is further than allowed loop length" 127 " from adjacent frozen block "

<< (prevFrozenBlock+1));

129 ERROR_MESSAGE

(

"Frozen block "

<< (block+1) <<

" is too far away from prior frozen block" 130 " given allowed intervening loop length(s) "

<< maxGapsLength

131

" plus unfrozen block length(s) "

<< unfrozenBlocksLength);

138

prevFrozenBlock = block;

139

unfrozenBlocksLength = maxGapsLength = 0;

148 unsigned int

queryFrom,

unsigned int

queryTo)

150 unsigned int

block, residue, prevResidue, lastBlock =

blocks

nBlocks

- 1;

155 for

(block=0; block<=lastBlock; ++block) {

157

firstPos[0] = queryFrom;

161

lastPos[lastBlock - block] =

167 for

(block=0; block<=lastBlock; ++block) {

173

<< (block+1) <<

" does not leave room for unfrozen blocks"

);

181 for

(residue=firstPos[0]; residue<=lastPos[0]; ++residue)

182

matrix[0][residue - queryFrom].score = BlockScore(0, residue);

185 bool

blockScoreCalculated;

186 for

(block=1; block<=lastBlock; ++block) {

187 for

(residue=firstPos[block]; residue<=lastPos[block]; ++residue) {

188

blockScoreCalculated =

false

;

190 for

(prevResidue=firstPos[block - 1]; prevResidue<=lastPos[block - 1]; ++prevResidue) {

193 if

(residue < prevResidue + blocks->blockSizes[block - 1])

207 if

(!blockScoreCalculated) {

208

score = BlockScore(block, residue);

211

blockScoreCalculated =

true

;

215

sum = score + matrix[block - 1][prevResidue - queryFrom].score;

216 if

(sum > matrix[block][residue - queryFrom].score) {

217

matrix[block][residue - queryFrom].score = sum;

218

matrix[block][residue - queryFrom].tracebackResidue = prevResidue;

230 unsigned int

queryFrom,

unsigned int

queryTo)

232 unsigned int

block, residue, prevResidue, lastBlock =

blocks

nBlocks

- 1;

233 int

blockScore = 0, sum;

234 unsigned int

loopPenalty;

238 for

(block=0; block<=lastBlock; ++block) {

240

firstPos[0] = queryFrom;

244

lastPos[lastBlock - block] =

250 for

(block=0; block<=lastBlock; ++block) {

256

<< (block+1) <<

" does not leave room for unfrozen blocks"

);

264 for

(residue=firstPos[0]; residue<=lastPos[0]; ++residue)

265

matrix[0][residue - queryFrom].score = BlockScore(0, residue);

268 bool

blockScoreCalculated;

269 for

(block=1; block<=lastBlock; ++block) {

270 for

(residue=firstPos[block]; residue<=lastPos[block]; ++residue) {

271

blockScoreCalculated =

false

;

273 for

(prevResidue=firstPos[block - 1]; prevResidue<=lastPos[block - 1]; ++prevResidue) {

276 if

(residue < prevResidue + blocks->blockSizes[block - 1])

289

loopPenalty = LoopScore(block - 1, residue - prevResidue -

blocks

blockSizes

[block - 1]);

295 if

(!blockScoreCalculated) {

296

blockScore = BlockScore(block, residue);

299

blockScoreCalculated =

true

;

303

sum = blockScore + matrix[block - 1][prevResidue - queryFrom].score - loopPenalty;

304 if

(sum > matrix[block][residue - queryFrom].score) {

305

matrix[block][residue - queryFrom].score = sum;

306

matrix[block][residue - queryFrom].tracebackResidue = prevResidue;

318 unsigned int

queryFrom,

unsigned int

queryTo)

320 unsigned int

block, residue, prevResidue, lastBlock =

blocks

nBlocks

- 1, tracebackResidue = 0;

321 int

score, sum, bestPrevScore;

325 for

(block=0; block<=lastBlock; ++block) {

327 ERROR_MESSAGE

(

"Block "

<< (block+1) <<

" too large for this query range"

);

334 for

(residue=queryFrom; residue<=lastPos[0]; ++residue) {

335

score = BlockScore(0, residue);

336

matrix[0][residue - queryFrom].score = (score > 0) ? score : 0;

340 for

(block=1; block<=lastBlock; ++block) {

341

score = BlockScore(block, queryFrom);

342

matrix[block][0].score = (score > 0) ? score : 0;

346 for

(block=1; block<=lastBlock; ++block) {

347 for

(residue=queryFrom+1; residue<=lastPos[block]; ++residue) {

350

score = BlockScore(block, residue);

356 for

(prevResidue=queryFrom; prevResidue<=lastPos[block - 1]; ++prevResidue) {

359 if

(residue < prevResidue + blocks->blockSizes[block - 1])

367 if

(matrix[block - 1][prevResidue - queryFrom].score > bestPrevScore) {

368

bestPrevScore = matrix[block - 1][prevResidue - queryFrom].score;

369

tracebackResidue = prevResidue;

374 if

(bestPrevScore > 0 && (sum=bestPrevScore+score) > 0) {

375

matrix[block][residue - queryFrom].score = sum;

376

matrix[block][residue - queryFrom].tracebackResidue = tracebackResidue;

381

matrix[block][residue - queryFrom].score = score;

391 unsigned int

queryFrom,

unsigned int

queryTo)

393 unsigned int

block, residue, prevResidue, loopPenalty,

395 int

score, sum, bestPrevScore;

399 for

(block=0; block<=lastBlock; ++block) {

401 ERROR_MESSAGE

(

"Block "

<< (block+1) <<

" too large for this query range"

);

408 for

(residue=queryFrom; residue<=lastPos[0]; ++residue) {

409

score = BlockScore(0, residue);

410

matrix[0][residue - queryFrom].score = (score > 0) ? score : 0;

414 for

(block=1; block<=lastBlock; ++block) {

415

score = BlockScore(block, queryFrom);

416

matrix[block][0].score = (score > 0) ? score : 0;

420 for

(block=1; block<=lastBlock; ++block) {

421 for

(residue=queryFrom+1; residue<=lastPos[block]; ++residue) {

424

score = BlockScore(block, residue);

430 for

(prevResidue=queryFrom; prevResidue<=lastPos[block - 1]; ++prevResidue) {

433 if

(residue < prevResidue + blocks->blockSizes[block - 1])

441

loopPenalty = LoopScore(block - 1, residue - prevResidue -

blocks

blockSizes

[block - 1]);

446

sum = matrix[block - 1][prevResidue - queryFrom].score - loopPenalty;

447 if

(sum > bestPrevScore) {

449

tracebackResidue = prevResidue;

454 if

(bestPrevScore > 0 && (sum=bestPrevScore+score) > 0) {

455

matrix[block][residue - queryFrom].score = sum;

456

matrix[block][residue - queryFrom].tracebackResidue = tracebackResidue;

461

matrix[block][residue - queryFrom].score = score;

472

vector < unsigned int > blockPositions;

473 unsigned int

block = lastBlock, pos = lastBlockPos;

475

blockPositions.push_back(pos);

476

pos = matrix[block][pos - queryFrom].tracebackResidue;

479 unsigned int

firstBlock = block + 1;

482

alignment->

score

= matrix[lastBlock][lastBlockPos - queryFrom].score;

484

alignment->

nBlocks

= blockPositions.size();

485

alignment->

blockPositions

new unsigned int

[blockPositions.size()];

486 for

(block=0; block<blockPositions.size(); ++block)

487

alignment->

blockPositions

[block] = blockPositions[lastBlock - firstBlock - block];

497 ERROR_MESSAGE

(

"TracebackGlobalAlignment() - NULL alignment handle"

);

504 unsigned int

residue, lastBlockPos = 0;

505 for

(residue=queryFrom; residue<=queryTo; ++residue) {

506 if

(matrix[

blocks

nBlocks

- 1][residue - queryFrom].score > score) {

507

score = matrix[

blocks

nBlocks

- 1][residue - queryFrom].score;

508

lastBlockPos = residue;

513 ERROR_MESSAGE

(

"TracebackGlobalAlignment() - somehow failed to find any allowed global alignment"

);

527 ERROR_MESSAGE

(

"TracebackLocalAlignment() - NULL alignment handle"

);

534 unsigned int

block, residue, lastBlock = 0, lastBlockPos = 0;

536 for

(residue=queryFrom; residue<=queryTo; ++residue) {

537 if

(matrix[block][residue - queryFrom].score > score) {

538

score = matrix[block][residue - queryFrom].score;

540

lastBlockPos = residue;

565 ERROR_MESSAGE

(

"TracebackMultipleLocalAlignments() - NULL alignments handle"

);

570 unsigned int

block, residue;

573

usedCells[block].

resize

(queryTo - queryFrom + 1,

false

);

576

list < Traceback > tracebacks;

577 while

(maxAlignments == 0 || tracebacks.size() < maxAlignments) {

581 unsigned int

lastBlock = 0, lastBlockPos = 0;

583 for

(residue=queryFrom; residue<=queryTo; ++residue) {

584 if

(!usedCells[block][residue - queryFrom] &&

585

matrix[block][residue - queryFrom].score > score)

587

score = matrix[block][residue - queryFrom].score;

589

lastBlockPos = residue;

599

residue = lastBlockPos;

600 bool

repeated =

false

;

602 if

(usedCells[block][residue - queryFrom]) {

606

usedCells[block][residue - queryFrom] =

true

;

608

residue = matrix[block][residue - queryFrom].tracebackResidue;

615

tracebacks.resize(tracebacks.size() + 1);

616

tracebacks.back().block = lastBlock;

617

tracebacks.back().residue = lastBlockPos;

620 if

(tracebacks.size() == 0) {

630 for

(

=0;

<tracebacks.size(); ++

)

631

(*alignments)->alignments[

].blockPositions =

NULL

;

634

list < Traceback >::const_iterator

, te = tracebacks.end();

635 for

(

=tracebacks.begin(),

=0;

!=te; ++

, ++

) {

636 if

(

TracebackAlignment

(matrix,

->block,

->residue, queryFrom, &((*alignments)->alignments[

]))

639

++((*alignments)->nAlignments);

661 unsigned int

queryFrom,

unsigned int

queryTo,

665 ERROR_MESSAGE

(

"DP_GlobalBlockAlign() - invalid parameters"

);

669 unsigned int i

, sumBlockLen = 0;

672 if

(sumBlockLen > queryTo - queryFrom + 1) {

673 ERROR_MESSAGE

(

"DP_GlobalBlockAlign() - sum of block lengths longer than query region"

);

679 ERROR_MESSAGE

(

"DP_GlobalBlockAlign() - ValidateFrozenBlockPositions() returned error"

);

687 ERROR_MESSAGE

(

"DP_GlobalBlockAlign() - CalculateGlobalMatrix() failed"

);

697 unsigned int

queryFrom,

unsigned int

queryTo,

701

!BlockScore || !LoopScore) {

702 ERROR_MESSAGE

(

"DP_GlobalBlockAlignGeneric() - invalid parameters"

);

706 unsigned int i

, sumBlockLen = 0;

709 if

(sumBlockLen > queryTo - queryFrom + 1) {

710 ERROR_MESSAGE

(

"DP_GlobalBlockAlignGeneric() - sum of block lengths longer than query region"

);

716 ERROR_MESSAGE

(

"DP_GlobalBlockAlignGeneric() - ValidateFrozenBlockPositions() returned error"

);

724 ERROR_MESSAGE

(

"DP_GlobalBlockAlignGeneric() - CalculateGlobalMatrixGeneric() failed"

);

733 unsigned int

queryFrom,

unsigned int

queryTo,

737 ERROR_MESSAGE

(

"DP_LocalBlockAlign() - invalid parameters"

);

740 for

(

unsigned int

block=0; block<

blocks

nBlocks

; ++block) {

742 WARNING_MESSAGE

(

"DP_LocalBlockAlign() - frozen block specifications are ignored..."

);

751 ERROR_MESSAGE

(

"DP_LocalBlockAlign() - CalculateLocalMatrix() failed"

);

760 unsigned int

queryFrom,

unsigned int

queryTo,

764 ERROR_MESSAGE

(

"DP_LocalBlockAlignGeneric() - invalid parameters"

);

767 for

(

unsigned int

block=0; block<

blocks

nBlocks

; ++block) {

769 WARNING_MESSAGE

(

"DP_LocalBlockAlignGeneric() - frozen block specifications are ignored..."

);

778 ERROR_MESSAGE

(

"DP_LocalBlockAlignGeneric() - CalculateLocalMatrixGeneric() failed"

);

787 unsigned int

queryFrom,

unsigned int

queryTo,

791 ERROR_MESSAGE

(

"DP_MultipleLocalBlockAlign() - invalid parameters"

);

794 for

(

unsigned int

block=0; block<

blocks

nBlocks

; ++block) {

796 WARNING_MESSAGE

(

"DP_MultipleLocalBlockAlign() - frozen block specifications are ignored..."

);

805 ERROR_MESSAGE

(

"DP_MultipleLocalBlockAlign() - CalculateLocalMatrix() failed"

);

814 unsigned int

queryFrom,

unsigned int

queryTo,

818 ERROR_MESSAGE

(

"DP_MultipleLocalBlockAlignGeneric() - invalid parameters"

);

821 for

(

unsigned int

block=0; block<

blocks

nBlocks

; ++block) {

823 WARNING_MESSAGE

(

"DP_MultipleLocalBlockAlignGeneric() - frozen block specifications are ignored..."

);

832 ERROR_MESSAGE

(

"DP_MultipleLocalBlockAlignGeneric() - CalculateLocalMatrixGeneric() failed"

);

847 for

(

unsigned int i

=0;

<nBlocks; ++

)

873 if

(!alignments)

return

;

882 unsigned int

nLoops,

const unsigned int

*loops,

883 double

percentile,

unsigned int

extension,

unsigned int

cutoff)

885

vector < unsigned int > loopLengths(nLoops);

886 unsigned int

index,

max

;

887 for

(index=0; index<nLoops; ++index)

888

loopLengths[index] = loops[index];

890

stable_sort(loopLengths.begin(), loopLengths.end());

892 if

(percentile < 1.0) {

893

index = (

unsigned int

)(percentile * (nLoops - 1) + 0.5);

894 max

= loopLengths[index] + extension;

896 max

= ((

unsigned int

)(percentile * loopLengths[nLoops - 1] + 0.5)) + extension;

899 if

(cutoff > 0 &&

max

> cutoff)

int TracebackAlignment(const Matrix &matrix, unsigned int lastBlock, unsigned int lastBlockPos, unsigned int queryFrom, DP_AlignmentResult *alignment)

int CalculateLocalMatrixGeneric(Matrix &matrix, const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, DP_LoopPenaltyFunction LoopScore, unsigned int queryFrom, unsigned int queryTo)

int TracebackMultipleLocalAlignments(const Matrix &matrix, const DP_BlockInfo *blocks, unsigned int queryFrom, unsigned int queryTo, DP_MultipleAlignmentResults **alignments, unsigned int maxAlignments)

int DP_LocalBlockAlign(const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, unsigned int queryFrom, unsigned int queryTo, DP_AlignmentResult **alignment)

int ValidateFrozenBlockPositions(const DP_BlockInfo *blocks, unsigned int queryFrom, unsigned int queryTo, bool checkGapSum)

int DP_MultipleLocalBlockAlignGeneric(const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, DP_LoopPenaltyFunction LoopScore, unsigned int queryFrom, unsigned int queryTo, DP_MultipleAlignmentResults **alignments, unsigned int maxAlignments)

int CalculateLocalMatrix(Matrix &matrix, const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, unsigned int queryFrom, unsigned int queryTo)

int CalculateGlobalMatrixGeneric(Matrix &matrix, const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, DP_LoopPenaltyFunction LoopScore, unsigned int queryFrom, unsigned int queryTo)

unsigned int DP_CalculateMaxLoopLength(unsigned int nLoops, const unsigned int *loops, double percentile, unsigned int extension, unsigned int cutoff)

void DP_DestroyBlockInfo(DP_BlockInfo *blocks)

int DP_GlobalBlockAlignGeneric(const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, DP_LoopPenaltyFunction LoopScore, unsigned int queryFrom, unsigned int queryTo, DP_AlignmentResult **alignment)

int DP_GlobalBlockAlign(const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, unsigned int queryFrom, unsigned int queryTo, DP_AlignmentResult **alignment)

void DP_DestroyAlignmentResult(DP_AlignmentResult *alignment)

#define WARNING_MESSAGE(s)

int TracebackGlobalAlignment(const Matrix &matrix, const DP_BlockInfo *blocks, unsigned int queryFrom, unsigned int queryTo, DP_AlignmentResult **alignment)

int TracebackLocalAlignment(const Matrix &matrix, const DP_BlockInfo *blocks, unsigned int queryFrom, unsigned int queryTo, DP_AlignmentResult **alignment)

void DP_DestroyMultipleAlignmentResults(DP_MultipleAlignmentResults *alignments)

int DP_LocalBlockAlignGeneric(const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, DP_LoopPenaltyFunction LoopScore, unsigned int queryFrom, unsigned int queryTo, DP_AlignmentResult **alignment)

DP_BlockInfo * DP_CreateBlockInfo(unsigned int nBlocks)

int CalculateGlobalMatrix(Matrix &matrix, const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, unsigned int queryFrom, unsigned int queryTo)

int DP_MultipleLocalBlockAlign(const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, unsigned int queryFrom, unsigned int queryTo, DP_MultipleAlignmentResults **alignments, unsigned int maxAlignments)

unsigned int tracebackResidue

virtual T * operator[](size_t i_)

vector< ResidueRow > Grid

vector< Cell > ResidueRow

Matrix(unsigned int nBlocks, unsigned int nResidues)

Include a standard set of the NCBI C++ Toolkit most basic headers.

#define END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_SCOPE(ns)

Define a new scope.

unsigned int

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

if(yy_accept[yy_current_state])

void resize(vector< SMethodDef > &container)

Defines NCBI C++ diagnostic APIs, classes, and macros.

unsigned int * blockPositions

unsigned int * freezeBlocks

unsigned int * blockPositions

unsigned int * blockSizes

DP_AlignmentResult * alignments

#define STRUCT_DP_FOUND_ALIGNMENT

#define STRUCT_DP_PARAMETER_ERROR

#define STRUCT_DP_ALGORITHM_ERROR

unsigned int(* DP_LoopPenaltyFunction)(unsigned int loopNumber, unsigned int loopLength)

static const unsigned int DP_POSITIVE_INFINITY

static const int DP_NEGATIVE_INFINITY

int(* DP_BlockScoreFunction)(unsigned int block, unsigned int queryPos)

static const unsigned int DP_UNFROZEN_BLOCK

#define STRUCT_DP_NO_ALIGNMENT

static DP_BlockInfo * blocks

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