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

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

NCBI C++ ToolKit: src/algo/structure/cd_utils/cuBlock.cpp Source File

:m_len(

), m_start(start), m_id(

)

:m_len(

), m_start(start), m_id(-1)

:m_len(-1), m_start(-1), m_id(-1)

:m_len(rhs.m_len), m_start(rhs.m_start), m_id(rhs.m_id)

!((*this) == rhs);

(

y = y0; y <= y1; y++)

( y >= x0 && y <= x1)

intersected =

;

( y >= x0 && y <= x1)

( y < x0 || y > x1)

comBlock.

= sit->m_id;

comBlock.

= sit->m_start;

comBlock.

= sit->m_len;

(; sit !=

.end(); ++sit)

( (comBlock.

() + 1) != sit->m_start)

comBlock.

+= sit->m_len;

: m_blocks(), m_seqId()

: m_blocks(), m_seqId()

vector<int> lens, starts;

(lens.size() == starts.size());

(

= 0;

< lens.size();

++)

: m_blocks(rhs.m_blocks), m_seqId(rhs.m_seqId)

(

= 0;

<

.size();

++)

(

= 0;

<

.size();

++)

nBlocks =

.size(), commonBlockExtSize = (commonBlockExt) ? commonBlockExt->size() : 0;

, j, k;

thisStart, thisLen, thisContiguousLen;

commonNTermBlockZeroExt, nTermShift;

completeBlockStart, completeBlockLen;

prevCTermBlockExt, allowedCTermBlockExt, lastCTermBlockExt;

blockNumberOnThisOfCompleteBlockStart;

vector<int> commonCTermBlockExt, gapSizeAfterBlockInThis;

useInputBlockExtensions = (commonBlockExt && commonBlockExtSize == nBlocks + 1);

completeExtendsIntoGappedRegionInThis =

;

commonNTermBlockZeroExt = (useInputBlockExtensions) ? (*commonBlockExt)[0] : 0;

(

= 0;

< nBlocks; ++

)

(

== nBlocks - 1) {

seqLen = sequenceLength;

commonCTermBlockExt.push_back((useInputBlockExtensions) ? (*commonBlockExt)[

+1] : 0);

prevCTermBlockExt = 0;

(j = 0; j < completeCopy.

().size() && !completeExtendsIntoGappedRegionInThis; ++j) {

blockNumberOnThisOfCompleteBlockStart = thisCopy.

(completeBlockStart);

(blockNumberOnThisOfCompleteBlockStart < 0 && nTermShift+1 < completeBlockLen) {

blockNumberOnThisOfCompleteBlockStart = thisCopy.

(completeBlockStart + nTermShift);

(nTermShift > 0 && blockNumberOnThisOfCompleteBlockStart >= 0) {

(blockNumberOnThisOfCompleteBlockStart == 0) {

(commonNTermBlockZeroExt - nTermShift < 0) {

(gapSizeAfterBlockInThis[blockNumberOnThisOfCompleteBlockStart - 1] - prevCTermBlockExt < nTermShift) {

}

(blockNumberOnThisOfCompleteBlockStart < 0) {

allowedCTermBlockExt = commonCTermBlockExt[blockNumberOnThisOfCompleteBlockStart];

thisStart = thisCopy.

(blockNumberOnThisOfCompleteBlockStart).

();

thisLen = thisCopy.

(blockNumberOnThisOfCompleteBlockStart).

();

(thisStart - completeBlockStart > nTermShift) {

completeExtendsIntoGappedRegionInThis =

;

(thisLen + allowedCTermBlockExt - (completeBlockStart - thisStart) >= completeBlockLen) {

prevCTermBlockExt = completeBlockLen - thisLen + (completeBlockStart - thisStart);

(prevCTermBlockExt < 0) prevCTermBlockExt = 0;

k = (unsigned) blockNumberOnThisOfCompleteBlockStart;

thisContiguousLen = thisLen + allowedCTermBlockExt;

lastCTermBlockExt = allowedCTermBlockExt;

(k + 1 < gapSizeAfterBlockInThis.size() && gapSizeAfterBlockInThis[k] == commonCTermBlockExt[k]) {

lastCTermBlockExt = gapSizeAfterBlockInThis[k];

thisContiguousLen += thisCopy.

(k).

() + lastCTermBlockExt;

(thisContiguousLen - (completeBlockStart - thisStart) >= completeBlockLen) {

prevCTermBlockExt = thisContiguousLen - completeBlockLen - (completeBlockStart - thisStart);

(prevCTermBlockExt > lastCTermBlockExt || prevCTermBlockExt < 0) {

prevCTermBlockExt = 0;

completeExtendsIntoGappedRegionInThis =

;

completeExtendsIntoGappedRegionInThis;

(

= 0;

<

.size();

++)

(

= 0;

<

.m_blocks.size();

++)

uniqueDelta.

(*dit);

->insert(*sit);

(

= 0;

<

.m_blocks.size();

++)

resultBlockID = 0;

(; dt !=

.end(); ++dt)

(dt->objectBlockID < 0 || dt->objectBlockID >= (

)

.size())

pair<BlockModel*, bool>(

,

);

block = srcBlock + (*dt);

->m_blocks.push_back(block);

pair<BlockModel*, bool>(

, (

->getBlocks().size() ==

.size()) );

pair<DeltaBlockModel*, bool> deltaStatus = target - (*this);

(!(deltaStatus.second))

deltaStatus.first;

pair<BlockModel*, bool> bmStatus = (*this) + (*deltaStatus.first);

deltaStatus.first;

(target.

(*(bmStatus.first)))

bmStatus.first;

bmStatus.first;

vector<int> blockIds;

(blockIds.size() <= 0)

(

j = 0; j < blockIds.size(); j++)

vector<int> blockIds;

(blockIds.size() <= 0)

(

j = 0; j < blockIds.size(); j++)

intersectedBlock(aBlock);

.insert(intersectedBlock - aBlock);

(

= 0;

<

.size();

++)

(

= 0;

<

.size();

++)

vector< CRef< CSeq_id > >& seqIds = dd->SetIds();

masterCopy->Assign(*(master.

()));

seqIds.push_back(masterCopy);

seqIds.push_back(slaveCopy);

starts.push_back(master.

[

].getStart());

starts.push_back(

[

].getStart());

ddList.push_back(dd);

lastBlock.

();

(

= 0;

<

.size();

++)

(bn == (

) (

.size() - 1))

(

= 1;

<

.size();

++)

(

= 1;

<

.size();

++)

errBlock = (

)

;

errBlock = (

)

- 1;

bmLo =

.getFirstAlignedPosition();

bmHi =

.getLastAlignedPosition();

vector<Block> maskedBlocks;

vector<Block>& originalBlocks =

();

, nOrigBlocks = originalBlocks.size();

nMaskBlocks = maskBlocks.size();

pos, start,

;

origStart, origEnd;

j, maskBlockStart, maskBlockEnd, maskFirst, maskLast;

(nOrigBlocks == 0 || nMaskBlocks == 0)

;

(

= 0;

< nMaskBlocks; ++

) {

maskBlockStart = maskBlocks[

].getStart();

maskBlockEnd = maskBlocks[

].getEnd();

(j = maskBlockStart; j <= maskBlockEnd; ++j) maskPositions.

(j);

maskPosEnd = maskPositions.

();

maskFirst = maskBlocks[0].getStart();

maskLast = maskBlocks.back().getEnd();

(

= 0;

< nOrigBlocks; ++

) {

origStart = originalBlocks[

].getStart();

origEnd = originalBlocks[

].getEnd();

(origEnd < maskFirst || origStart > maskLast) {

maskedBlocks.push_back(originalBlocks[

]);

maskedBlocks.back().setId(newBlockId);

(pos = origStart; pos <= origEnd; ++pos) {

(maskPositions.

(pos) != maskPosEnd) {

maskedBlocks.push_back(

(start,

, newBlockId));

maskedBlocks.push_back(

(start,

, newBlockId));

originalBlocks.clear();

originalBlocks = maskedBlocks;

nBlocks =

().size();

(nBlocks == 0)

;

vector<Block> maskBlocks;

firstAligned =

().front().getStart();

lastAligned =

().back().getEnd();

(firstAligned < (

)

) {

maskBlocks.push_back(

(firstAligned,

- firstAligned));

(lastAligned > (

)

) {

maskBlocks.push_back(

(

+ 1, lastAligned -

));

blockModelStr,

;

nBlocks =

.size();

(

= 0;

< nBlocks; ++

) {

blockModelStr +=

;

blockModelStr;

deltaBlockModelStr,

;

(; dbm_cit != dbm_citEnd; ++dbm_cit) {

deltaBlockModelStr +=

;

deltaBlockModelStr;

.toString();

m_master(0), m_slave(0)

(

= 0;

< num;

++)

(ngap > ngapSlave)

(cgap > cgapSlave)

pair<BlockModel*, bool> intersectedGuideSlave = guide.

() + *(deltaGuideToThis.first);

pair<BlockModel*, bool> intersectedThisSlave = (*m_slave) + *(deltaThisToGuide.first);

(intersectedGuideSlave.first && intersectedThisSlave.first) {

((intersectedGuideSlave.first)->blockMatch(*(intersectedThisSlave.first)));

= intersectedGuideSlave.first;

= intersectedThisSlave.first;

hasEffect =

;

vector<Block>& newBlocks = maskedBm.

();

, nBlocks = newBlocks.size();

(maskBlocks.size() > 0 && nBlocks > 0 && maskedBm.

(maskBlocks)) {

newOtherBlocks.clear();

(

= 0;

< nBlocks; ++

) {

pos =

.getStart();

(mappedPos >= 0) {

newOtherBlocks.push_back(

(mappedPos,

.getLen(),

.getId()));

int mapToSlave(int masterPos) const

BlockModelPair & operator=(const BlockModelPair &rhs)

CRef< CSeq_align > toSeqAlign() const

int mapToMaster(int slavePos) const

int remaster(const BlockModelPair &guide)

void extendMidway(int blockNum)

bool mask(const vector< Block > &maskBlocks, bool maskBasedOnMaster)

int getTotalBlockLength() const

bool mask(const BlockModel &maskBlockModel)

BlockModel * completeCastTo(const BlockModel &target) const

CRef< CSeq_id > getSeqId() const

int getLastAlignedPosition() const

bool isValid(int seqLen, int &errBlock) const

bool contain(const BlockModel &rhs) const

CRef< CSeq_align > toSeqAlign(const BlockModel &master) const

int getFirstAlignedPosition() const

bool completeModelExtendsIntoUnallowedGappedRegion(const BlockModel &completeModel, int sequenceLength, const vector< int > *commonBlockExt=NULL) const

void addBlock(Block &block)

int getGapToNTerminal(int bn) const

int getGapToCTerminal(int bn, int len=-1) const

pair< DeltaBlockModel *, bool > intersect(const BlockModel &bm) const

void findIntersectingBlocks(const Block &target, vector< int > &result) const

vector< Block > & getBlocks()

void clipToRange(unsigned int min, unsigned max)

pair< DeltaBlockModel *, bool > operator-(const BlockModel &bm) const

bool overlap(const BlockModel &bm) const

BlockModel & operator=(const BlockModel &rhs)

bool blockMatch(const BlockModel &bm) const

bool minusOneBlock(const Block &aBlock, DeltaBlockModel &delta) const

int getBlockNumber(int pos) const

pair< BlockModel *, bool > operator+(const DeltaBlockModel &delta) const

bool isAlike(const BlockModel &rhs) const

bool intersectOneBlock(const Block &aBlock, DeltaBlockModel &delta) const

bool operator==(const BlockModel &rhs) const

DeltaBlock operator-(const Block &object) const

bool intersect(Block &rhs) const

bool isIntersecting(const Block &rhs) const

static bool concatenate(const SortedBlocks &blocks, Block &comBlock)

bool contain(const Block &rhs) const

Block extend(int nExt, int cExt) const

bool operator!=(const Block &rhs) const

Block operator+(const DeltaBlock &deltaBlock) const

const Block & operator=(const Block &rhs)

void extendSelf(int nExt, int cExt)

bool operator==(const Block &rhs) const

const_iterator begin() const

const_iterator end() const

parent_type::iterator iterator

parent_type::const_iterator const_iterator

iterator_bool insert(const value_type &val)

const_iterator begin() const

parent_type::iterator iterator

const_iterator find(const key_type &key) const

const_iterator end() const

parent_type::const_iterator const_iterator

CSeq_align::C_Segs::TDendiag TDendiag

int GetBlockLengths(const CRef< CSeq_align > &seqAlign, vector< int > &lengths)

bool GetSeqID(const CRef< CSeq_align > &seqAlign, CRef< CSeq_id > &SeqID, bool getSlave=true)

int GetBlockStarts(const CRef< CSeq_align > &seqAlign, vector< int > &starts, bool onMaster)

string DeltaBlockModelToString(const DeltaBlockModel &dbm)

multiset< DeltaBlock > DeltaBlockModel

bool SeqIdsMatch(const CRef< CSeq_id > &id1, const CRef< CSeq_id > &id2)

string GetSeqIDStr(const CRef< CSeq_id > &SeqID)

virtual void Assign(const CSerialObject &source, ESerialRecursionMode how=eRecursive)

Optimized implementation of CSerialObject::Assign, which is not so efficient.

bool NotEmpty(void) const THROWS_NONE

Check if CRef is not empty – pointing to an object and has a non-null value.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

#define BEGIN_SCOPE(ns)

Define a new scope.

static string IntToString(int value, TNumToStringFlags flags=0, int base=10)

Convert int to string.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

void SetDim(TDim value)

Assign a value to Dim data member.

vector< TSeqPos > TStarts

void SetType(TType value)

Assign a value to Type data member.

virtual void Reset(void)

Reset the whole object.

@ eType_partial

mapping pieces together

unsigned int

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

Int4 delta(size_t dimension_, const Int4 *score_)

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