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

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

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

ret = residues.find(eaa);

ret = residues.find(

);

(ret);

[

(stdCode)];

: m_masterIn(

), m_residueRowsMap(), m_residueTypeCount(0), m_indexByConsensus(-1)

= 0;

w = 1.0/denom;

w = 1.0/denom;

rowWeights[cit->second.first] += colResWeight;

total += colResWeight;

rowsUsed.

(cit->second.first);

(countGap && ((

)rowsUsed.

() < numRows))

gapWeight = (1.0 - total) / (numRows - rowsUsed.

());

(

= 0;

< numRows;

++)

(rowsUsed.

(

) != rowsUsed.

())

rowWeights[

] += gapWeight;

totalWeight = 0;

maxResWeight = 0;

resWeight = 0;

pair <ResidueRowsMap::const_iterator, ResidueRowsMap::const_iterator> range =

= cit->second.first;

resWeight += rowWeights[

];

(resWeight > maxResWeight)

maxResWeight = resWeight;

totalWeight += resWeight;

residues[rit->second.first] = rit->first;

pair <ResidueRowsMap::const_iterator, ResidueRowsMap::const_iterator> range =

(cit->second.first ==

)

cit->second.second;

(*cit)->second.second;

(!(cit->second.second))

backgroundResFreq[

] = 7.67/100.0;

backgroundResFreq[

] = 5.21/100.0;

backgroundResFreq[

] = 4.32/100.0;

backgroundResFreq[

] = 5.25/100.0;

backgroundResFreq[

] = 1.62/100.0;

backgroundResFreq[

] = 3.93/100.0;

backgroundResFreq[

] = 6.48/100.0;

backgroundResFreq[

] = 6.88/100.0;

backgroundResFreq[

] = 2.25/100.0;

backgroundResFreq[

] = 5.85/100.0;

backgroundResFreq[

] = 9.56/100.0;

backgroundResFreq[

] = 5.95/100.0;

backgroundResFreq[

] = 2.37/100.0;

backgroundResFreq[

] = 4.08/100.0;

backgroundResFreq[

] = 4.89/100.0;

backgroundResFreq[

] = 7.04/100.0;

backgroundResFreq[

] = 5.55/100.0;

backgroundResFreq[

] = 1.20/100.0;

backgroundResFreq[

] = 3.14/100.0;

backgroundResFreq[

] = 6.63/100.0;

* backgroundResFreqArray = 0;

(backgroundResFreqArray == 0)

freqThreshold = 0.0001f;

ln2 =

(2.0f);

( standardFreq > freqThreshold)

freq = double(

)/total;

freqRatio = freq/standardFreq;

(freqRatio > freqThreshold)

+= freq * (

(freqRatio))/ln2;

: mPos(posOnMaster), gap(aGap)

: m_frequencyThreshold(0.5),

m_profiles(), m_rowWeights(),

m_consensus(), m_guideAlignment()

vector<Block>& mBlocks =

.getMaster().getBlocks();

vector<Block>& sBlocks =

.getSlave().getBlocks();

(

bn = 0; bn < mBlocks.size(); bn++)

(

= 0;

< mBlocks[bn].getLen();

++)

mPos = mBlocks[bn].getStart() +

;

sPos = sBlocks[bn].getStart() +

;

[col].addOccurence(mSeq[mPos], masterRow,

);

(bn != (mBlocks.size() -1))

mPos = mBlocks[bn].getEnd();

sPos = sBlocks[bn].getEnd();

sGapLen =

.getSlave().getGapToCTerminal(bn);

mGapLen =

.getMaster().getGapToCTerminal(bn);

(

gap =1; gap <= mGapLen; gap++)

[col].addOccurence(mSeq[mPos+gap], masterRow,

);

midOnMaster = mGapLen/2 + mGapLen%2;

mid = sGapLen/2 + sGapLen%2;

(

gap =1; gap <= sGapLen; gap++)

(gap <= midOnMaster)

col.

= mPos + gap;

col.

= mPos + midOnMaster;

col.

= gap - midOnMaster;

mPosNext = mBlocks[bn+1].getStart();

sPosNext = sBlocks[bn+1].getStart();

= sPosNext - (sPos + gap);

(

<= (mGapLen/2))

col.

= mPosNext - (mGapLen/2);

countGap =

;

weightsSum = 0;

highestCount = 0;

aCount = cit->second.getSumCount();

(aCount > highestCount)

highestCount = aCount;

defaultWeight = 0.0;

defaultWeight = 1.0f * double(colUsed)/double(

);

noWeightRows = 0;

blocksOnMaster.clear();

blocksOnConsensus.clear();

inBlock =

;

startM = 0, endM = 0;

qualifiedForConsensus = (

>= threshold && res );

qualifiedForGuide = qualifiedForConsensus && ((cit->second).isAligned(0));

(qualifiedForGuide)

(qualifiedForGuide)

(col.

== (endM + 1))

blocksOnMaster.push_back(

(startM, endM - startM + 1, blockId));

blocksOnConsensus.push_back(

(startC, endM - startM + 1, blockId));

blocksOnMaster.push_back(

(startM, endM - startM + 1, blockId));

blocksOnConsensus.push_back(

(startC, endM - startM + 1, blockId));

(qualifiedForConsensus)

cit->second.setIndexByConsensus(

.size());

blocksOnMaster.push_back(

(startM, endM - startM + 1, blockId));

blocksOnConsensus.push_back(

(startC, endM - startM + 1, blockId));

seq.assign(mcc.

());

cr.

(pit->second);

(pit->first.gap == 0)

mPos = pit->first.mPos;

cr.

(pit->second);

(pit->second.getIndexByConsensus() >= 0)

cr.

(pit->second);

(pit->second.isAllRowsAligned())

cr.

(pit->second);

useCol =

;

useCol = (cit->first.gap == 0);

blocksOnMaster.clear();

blocksOnConsensus.clear();

inBlock =

;

startM = 0, endM = 0;

qualifiedForGuide = qualifiedForConsensus && ((cit->second).isAligned(0));

(qualifiedForGuide)

(qualifiedForGuide)

(col.

== (endM + 1))

blocksOnMaster.push_back(

(startM, endM - startM + 1, blockId));

blocksOnConsensus.push_back(

(startC, endM - startM + 1, blockId));

blocksOnMaster.push_back(

(startM, endM - startM + 1, blockId));

blocksOnConsensus.push_back(

(startC, endM - startM + 1, blockId));

(qualifiedForConsensus)

(curMap.

(conIndex) != curMap.

()) {

(curMap.

(conIndex) != curMap.

()) {

blocksOnMaster.push_back(

(startM, endM - startM + 1, blockId));

blocksOnConsensus.push_back(

(startC, endM - startM + 1, blockId));

vector<UnalignedSegReader::Seg> segs;

(segs.size() == 0)

(

= 0;

< segs.size();

++)

(

k = segs[

].

; k <= segs[

].second; k++)

: m_totalUnaligned(0), m_pos(0)

seg.second - seg.first + 1 ;

=

.substr(0, seg.first);

tail =

.substr(seg.second + 1,

.size() - (seg.second + 1));

Various auxiliary BLAST utility functions.

double * BLAST_GetStandardAaProbabilities(void)

Get the standard amino acid probabilities.

vector< Block > & getBlocks()

bool operator<(const ColumnAddress &rhs) const

virtual void read(ColumnResidueProfile &crp)=0

double calculateColumnWeight(char residue, bool countGap, int numRows) const

double reweightColumnByRowWeights(const vector< double > &rowWeights, char &heaviestResidue) const

void addOccurence(char residue, int row, bool aligned)

unsigned char getResidueByRow(int row)

static int getResiduesStringSize()

pair< int, bool > RowStatusPair

static const string getResiduesString()

ResidueRowsMap::iterator * findRow(int row)

int getIndexByConsensus() const

bool isAllRowsAligned() const

double getBackgroundResFreq(char res)

void setIndexByConsensus(int col)

vector< ResidueRowsMap::iterator * > m_residuesByRow

double sumUpColumnWeightsByRow(vector< double > &rowWeights, bool countGap, int numRows) const

void getResiduesByRow(vector< char > &residues, bool byNcbiStd=true) const

ResidueRowsMap m_residueRowsMap

double calcInformationContent()

char getMostFrequentResidue(int &count) const

static unsigned char getNcbiStdCode(char eaa)

static char getEaaCode(char stdCode)

static void useDefaultBackgroundResFreq()

int getResidueTypeCount() const

bool isAligned(char residue, int row) const

vector< double > m_rowWeights

const string & makeConsensus()

set< int > m_colsToSkipOnConsensus

UnqualForConsMap::const_iterator UnqualForConsCit

void adjustConsensusAndGuide()

void traverseColumnsOnMaster(ColumnReader &cr)

BlockModelPair m_guideAlignment

UnqualForConsMap m_numUnqualAfterConsIndex

double calcInformationContent(bool byConsensus=true)

const string getConsensus(bool inNcbieaa=true)

set< int > m_colsToSkipOnMaster

void traverseAlignedColumns(ColumnReader &cr)

void countUnalignedConsensus(UnalignedSegReader &ucr)

const BlockModelPair & getGuideAlignment() const

bool HasUnqualAfterIndex(int index) const

int countColumnsOnMaster(string &seq)

unsigned int GetNumUnqualAfterIndex(int index) const

void calculateRowWeights()

void addOneRow(BlockModelPair &bmp, const string &mSeq, const string &sSeq)

void traverseAllColumns(ColumnReader &cr)

void traverseColumnsOnConsensus(ColumnReader &cr)

vector< CRef< CSeq_id > > m_seqIds

bool skipUnalignedSeg(UnalignedSegReader &ucr, int len)

void segsToSet(vector< UnalignedSegReader::Seg > &segs, set< int > &cols)

double m_frequencyThreshold

void read(ColumnResidueProfile &crp)

string getIndexSequence()

int getLongUnalignedSegs(int length, vector< Seg > &segs)

string subtractSeg(Seg seg, string &in)

vector< Seg > m_unalignedSegs

string subtractLongestSeg(int threshold)

void setIndexSequence(string &seq)

container_type::const_iterator const_iterator

container_type::iterator iterator

const_iterator begin() const

const_iterator end() const

const_iterator find(const key_type &key) const

const_iterator_pair equal_range(const key_type &key) const

container_type::const_iterator const_iterator

const_iterator end() const

iterator insert(const value_type &val)

const_iterator begin() const

container_type::iterator iterator

container_type::value_type value_type

iterator_bool insert(const value_type &val)

const_iterator find(const key_type &key) const

const_iterator end() const

static CSafeStatic< map< char, double > > s_BackgroundResFreq

static const size_t kResiduesSize

static const char kResidues[]

thread_local unique_ptr< FtaMsgPost > bmp

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

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

unsigned int

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

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

Int4 delta(size_t dimension_, const Int4 *score_)

#define row(bind, expected)

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