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

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

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

seqEntryCopy->Assign(seqEntry);

SeqAnnotList::const_iterator

, ae = seqAnnots.end();

(

=seqAnnots.begin();

!=ae; ++

) {

seqAnnotCopy->Assign(**

);

SeqEntryList::const_iterator s, se = seqEntries.end();

(s=seqEntries.begin(); s!=se; ++s) {

seqEntryCopy->

(**s);

SeqAnnotList::const_iterator

, ae = seqAnnots.end();

(

=seqAnnots.begin();

!=ae; ++

) {

AlignmentSet::AlignmentList::const_iterator

, ae = alignments.end();

(

=alignments.begin();

!=ae; ++

) {

AlignmentSet::AlignmentList::const_iterator

, ae = alignments.end();

(

=alignments.begin();

!=ae; ++

) {

(((*a)->m_masterToSlave[masterTo] - (*a)->m_masterToSlave[masterFrom]) != (masterTo - masterFrom))

AlignmentSet::AlignmentList::const_iterator

, ae = alignments.end();

(

=alignments.begin();

!=ae; ++

) {

((*a)->m_blockStructure[masterTo] != (*a)->m_blockStructure[masterFrom])

AlignmentSet::AlignmentList::const_iterator

, ae = alignments.end();

BlockMultipleAlignment::SequenceList::iterator s = sequenceList.begin();

*(s++) = alignments.front()->m_master;

(

=alignments.begin();

!=ae; ++

) {

*(s++) = (*a)->m_slave;

((*a)->m_master != sequenceList.front()) {

(

);

masterFrom = 0, masterTo,

;

(masterFrom < multipleAlignment->GetMaster()->Length()) {

(masterTo=masterFrom+1;

masterTo < multipleAlignment->GetMaster()->Length() &&

newBlock->

= masterTo - masterFrom + 1;

(

=alignments.begin(),

=1;

!=ae; ++

, ++

) {

(*a)->m_masterToSlave[masterFrom],

(*a)->m_masterToSlave[masterTo]);

multipleAlignment->AddAlignedBlockAtEnd(newBlock);

masterFrom = masterTo + 1;

(!multipleAlignment->AddUnalignedBlocks() || !multipleAlignment->UpdateBlockMap()) {

(

);

rowToRealign,

std::vector < unsigned int >& blocksToRealign,

percentile,

extension,

cutoff,

queryFrom,

queryTo)

(

.size() == 0) {

status =

;

(

=0;

<

.size()-1; ++

) {

range =

[

]->GetRangeOfRow(

);

nextRange =

[

+ 1]->GetRangeOfRow(

);

loopLengths[

] = nextRange->

- range->

- 1;

[] loopLengths;

vector < unsigned int > rowsToRemove(1, rowToRealign);

range =

[

]->GetRangeOfRow(0);

(blocksToRealign.size() == 0)

vector < bool > realignBlock(

.size(),

);

(

=0;

<blocksToRealign.size(); ++

) {

(blocksToRealign[

] <

.size())

realignBlock[blocksToRealign[

]] =

;

toRealign.front()->GetUngappedAlignedBlocks(&

);

(!realignBlock[

])

= toRealign.front()->GetSequenceOfRow(1)->Length();

(queryFrom >=

|| queryTo >=

|| queryFrom > queryTo)

(

<< queryFrom <<

<< queryTo);

= toRealign.front()->GetSequenceOfRow(1);

originalScore = 0;

toRealign.front()->GetUngappedAlignedBlocks(&ob);

BlockMultipleAlignment::UngappedAlignedBlockList::const_iterator

, o,

=

.end();

(

=

.begin(), o=ob.begin();

!=

; ++

, ++o) {

*masterRange = (*l)->GetRangeOfRow(0),

*range = (*o)->GetRangeOfRow(1);

(

=0;

<(*l)->m_width; ++

)

(

<< originalScore);

(

<< dpResult->

);

toRealign.front()->GetModifiableUngappedAlignedBlocks(&modBlocks);

(

=0;

<modBlocks.size(); ++

) {

(realignBlock[

]) {

modBlocks[

]->SetRangeOfRow(1,

((

)dpResult->

[

] != modBlocks[

]->GetRangeOfRow(1)->from)

(

);

(

);

(

< rowToRealign)

(

== rowToRealign)

rowOrder[

] =

- 1;

std::vector<unsigned int>& rowsToRealign,

std::vector < unsigned int >& blocksToRealign,

percentile,

extension,

cutoff,

std::vector<unsigned int>& queryFromVec, std::vector<unsigned int>& queryToVec)

LNO_MIN_NROWS_REMAINING = 3;

queryFrom, queryTo;

nToRealign = rowsToRealign.size(), nFailed = 0;

failedMsg, rowStr;

nDifferentToRealign;

vector<unsigned int> sortedRowsToRealign;

setOfRows.

(rowsToRealign.begin(), rowsToRealign.end());

nDifferentToRealign = setOfRows.

();

(nToRealign != nDifferentToRealign) {

(

);

(setIt = setOfRows.

(); setIt != setEnd; ++setIt) {

(*setIt < 1 || *setIt >=

) {

sortedRowsToRealign.push_back(*setIt);

nDifferentToRealign = sortedRowsToRealign.size();

(nDifferentToRealign >

- LNO_MIN_NROWS_REMAINING) {

(

<<

- LNO_MIN_NROWS_REMAINING <<

<< nDifferentToRealign <<

);

(

.size() == 0) {

(nToRealign != queryFromVec.size() || nToRealign != queryToVec.size()) {

(

);

status =

;

,

,

;

*loopLengths =

[

];

(

=0;

<

.size()-1; ++

) {

range =

[

]->GetRangeOfRow(

);

nextRange =

[

+ 1]->GetRangeOfRow(

);

loopLengths[

] = nextRange->

- range->

- 1;

, loopLengths, percentile, extension, cutoff);

[] loopLengths;

BlockMultipleAlignment::AlignmentList::iterator toRealignIt, toRealignEnd;

(nDifferentToRealign != toRealign.size()) {

(

);

range =

[

]->GetRangeOfRow(0);

(blocksToRealign.size() == 0)

vector < bool > realignBlock(

.size(),

);

(

=0;

<blocksToRealign.size(); ++

) {

(blocksToRealign[

] <

.size())

realignBlock[blocksToRealign[

]] =

;

toRealignIt = toRealign.begin();

toRealignEnd = toRealign.end();

(

=0;

< nDifferentToRealign; ++

, ++toRealignIt) {

= sortedRowsToRealign[

];

(

< nToRealign && rowsToRealign[

] !=

) {

(

< nToRealign) {

queryFrom = queryFromVec[

];

queryTo = queryToVec[

];

failedMsg.append(

+ rowStr);

(*toRealignIt)->GetUngappedAlignedBlocks(&

);

(!realignBlock[

])

= (*toRealignIt)->GetSequenceOfRow(1)->Length();

(queryFrom >=

|| queryTo >=

|| queryFrom > queryTo) {

failedMsg.append(

+ rowStr);

(

<<

<<

<<

<<

<< queryFrom <<

<< queryTo);

= (*toRealignIt)->GetSequenceOfRow(1);

originalScore = 0;

(*toRealignIt)->GetUngappedAlignedBlocks(&ob);

BlockMultipleAlignment::UngappedAlignedBlockList::const_iterator

, o,

=

.end();

(

=

.begin(), o=ob.begin();

!=

; ++

, ++o) {

*masterRange = (*l)->GetRangeOfRow(0),

*range = (*o)->GetRangeOfRow(1);

(

=0;

<(*l)->m_width; ++

)

(

<< nDifferentToRealign <<

<< originalScore);

failedMsg.append(

+ rowStr);

(

<< nDifferentToRealign <<

<< dpResult->

);

(*toRealignIt)->GetModifiableUngappedAlignedBlocks(&modBlocks);

(

=0;

<modBlocks.size(); ++

) {

(!realignBlock[

]) {

((

)dpResult->

[

] != modBlocks[

]->GetRangeOfRow(1)->from) {

failedMsg.append(

+ rowStr);

(

=0;

<modBlocks.size(); ++

) {

(realignBlock[

]) {

modBlocks[

]->SetRangeOfRow(1,

(

<<

+ failedMsg +

);

(

);

toRealignIt = toRealign.end();

(

j=nDifferentToRealign-1; j >=0; --j, --toRealignIt) {

= sortedRowsToRealign[j];

(

+ rowStr);

rowOrder[

] =

- 1;

(

+ rowStr);

(

);

(

);

(

.size() == 0) {

(

);

BlockMultipleAlignment::UngappedAlignedBlockList::const_iterator

, be =

.end();

(

=

.begin();

!=be; ++

) {

*masterRange = (*b)->GetRangeOfRow(0),

*range = (*b)->GetRangeOfRow(

);

(

=0;

<(*b)->m_width; ++

)

(bma) ? bma->

() : 0;

= 0;

defStr =

;

s =

+

.GetPdb().GetMol().Get() +

+

.GetPdb().GetEffectiveChain_id();

}

(

.IsGi()) {

defStr =

;

defStr =

;

idStr =

->GetSeqIdStringForRow(

);

#define WARNING_MESSAGE(s)

list< CRef< objects::CSeq_annot > > SeqAnnotList

vector< const MasterSlaveAlignment * > AlignmentList

AlignmentList m_alignments

static AlignmentSet * CreateFromMultiple(const BlockMultipleAlignment *multiple, SeqAnnotList *newAsnAlignmentData, const SequenceSet &sequenceSet, const std::vector< unsigned int > *rowOrder=NULL)

const SeqAnnotList & GetSeqAnnots(void)

void RemoveAlignAnnot(void)

const BlockMultipleAlignment * GetBlockMultipleAlignment(void)

const BLAST_Matrix * GetPSSM(void)

void RemoveMultiple(void)

bool IsRowPDB(unsigned int row)

AlignmentUtility(const ncbi::objects::CSeq_entry &seqEntry, const SeqAnnotList &seqAnnots)

std::string GetSeqIdStringForRow(unsigned int row)

void SetBlockMultipleAlignment(const BlockMultipleAlignment *bma)

bool DoLeaveOneOut(unsigned int row, const std::vector< unsigned int > &blocksToRealign, double percentile, unsigned int extension, unsigned int cutoff, unsigned int queryFrom=0, unsigned int queryTo=kMax_UInt)

AlignmentSet * m_alignmentSet

std::list< ncbi::CRef< ncbi::objects::CSeq_entry > > SeqEntryList

AlignmentUtility * Clone() const

int ScoreRowByPSSM(unsigned int row)

SeqEntryList m_seqEntries

std::list< ncbi::CRef< ncbi::objects::CSeq_annot > > SeqAnnotList

BlockMultipleAlignment * m_currentMultiple

SequenceSet * m_sequenceSet

bool DoLeaveNOut(std::vector< unsigned int > &rowsToRealign, const std::vector< unsigned int > &blocksToRealign, double percentile, unsigned int extension, unsigned int cutoff, std::vector< unsigned int > &queryFrom, std::vector< unsigned int > &queryTo)

BlockMultipleAlignment * Clone(void) const

std::list< BlockMultipleAlignment * > AlignmentList

std::vector< const Sequence * > SequenceList

const BLAST_Matrix * GetPSSM(void) const

bool ReorderRows(const std::vector< unsigned int > &newOrder)

std::vector< const UngappedAlignedBlock * > UngappedAlignedBlockList

bool ExtractRows(const std::vector< unsigned int > &slavesToRemove, AlignmentList *pairwiseAlignments)

const Sequence * GetSequenceOfRow(unsigned int row) const

void GetUngappedAlignedBlocks(UngappedAlignedBlockList *blocks) const

unsigned int NRows(void) const

std::vector< UngappedAlignedBlock * > ModifiableUngappedAlignedBlockList

bool MergeAlignment(const BlockMultipleAlignment *newAlignment)

void SetRangeOfRow(unsigned int row, int from, int to)

std::string m_sequenceString

const ncbi::objects::CSeq_id & GetPreferredIdentifier(void) const

unsigned int Length(void) const

std::string IdentifierString(void) const

iterator_bool insert(const value_type &val)

const_iterator begin() const

const_iterator end() const

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

#define ERR_POST(message)

Error posting with file, line number information but without error codes.

void Error(CExceptionArgs_Base &args)

const string & GetMsg(void) const

Get message string.

static bool EnableBackgroundReporting(bool enable)

Enable background reporting.

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

Set object to copy of another one.

TObjectType * Release(void)

Release a reference to the object and return a pointer to the object.

#define END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_SCOPE(ns)

Define a new scope.

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

Convert int to string.

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

Convert UInt to string.

static enable_if< is_arithmetic< TNumeric >::value||is_convertible< TNumeric, Int8 >::value, string >::type NumericToString(TNumeric value, TNumToStringFlags flags=0, int base=10)

Convert numeric value to string.

if(yy_accept[yy_current_state])

bool le(T x_, T y_, T round_)

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

static SLJIT_INLINE sljit_ins l(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

#define row(bind, expected)

unsigned int * blockPositions

unsigned int * freezeBlocks

unsigned int * blockPositions

unsigned int * blockSizes

void DP_DestroyBlockInfo(DP_BlockInfo *blocks)

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

#define STRUCT_DP_FOUND_ALIGNMENT

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

static const int DP_NEGATIVE_INFINITY

void DP_DestroyAlignmentResult(DP_AlignmentResult *alignment)

DP_BlockInfo * DP_CreateBlockInfo(unsigned int nBlocks)

static DP_BlockInfo * blocks

string SequenceIdToString(const Sequence &sequence)

DP_BlockInfo * g_dpBlocks

static bool AlignedToAllSlaves(unsigned int masterResidue, const AlignmentSet::AlignmentList &alignments)

static bool NoSlaveInsertionsBetween(unsigned int masterFrom, unsigned int masterTo, const AlignmentSet::AlignmentList &alignments)

static bool NoBlockBoundariesBetween(unsigned int masterFrom, unsigned int masterTo, const AlignmentSet::AlignmentList &alignments)

const Sequence * g_dpQuery

int ScoreByPSSM(unsigned int block, unsigned int queryPos)

const BLAST_Matrix * g_dpPSSM

#define THROW_MESSAGE(str)

#define DELETE_ALL_AND_CLEAR(container, ContainerType)

int GetPSSMScoreOfCharWithAverageOfBZ(const BLAST_Matrix *matrix, unsigned int pssmIndex, char resChar)

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