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

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

NCBI C++ ToolKit: src/app/cn3d/conservation_colorer.cpp Source File

unpacked =

;

alignment(parent), nColumns(0), basicColorsCurrent(

), fitColorsCurrent(

)

(

);

(

);

ColumnProfile::iterator p, pe, p2;

, profileColumn;

vector < int > IntVector;

minVariety=0, maxVariety=0, minWeightedVariety=0, maxWeightedVariety=0;

vector < float > FloatVector;

FloatVector informationContents(

, 0.0f);

totalInformationContent = 0.0f;

BlockMap::const_iterator

, be =

.end();

(

=

.begin();

!=be; ++

) {

(

blockColumn=0; blockColumn<

->first->width; ++blockColumn) {

profileColumn =

->second[blockColumn];

((p=profile.find(ch)) != profile.end())

(profile.size() == 1 && profile.begin()->first !=

)

& variety = varieties[profileColumn];

variety = profile.size();

(profile.find(

) != profile.end())

variety += profile[

] - 1;

(blockColumn == 0 &&

==

.begin()) {

minVariety = maxVariety = variety;

(variety < minVariety) minVariety = variety;

(variety > maxVariety) maxVariety = variety;

& weightedVariety = weightedVarieties[profileColumn];

(p=profile.begin(); p!=pe; ++p) {

(++p2; p2!=pe; ++p2)

(blockColumn == 0 &&

==

.begin()) {

minWeightedVariety = maxWeightedVariety = weightedVariety;

(weightedVariety < minWeightedVariety) minWeightedVariety = weightedVariety;

(weightedVariety > maxWeightedVariety) maxWeightedVariety = weightedVariety;

&columnInfo = informationContents[profileColumn];

(p=profile.begin(); p!=pe; ++p) {

ln2 =

(2.0f), threshhold = 0.0001f;

(expFreq > threshhold) {

obsFreq = 1.0f * p->second /

,

freqRatio = obsFreq / expFreq;

(freqRatio > threshhold) {

residueScore = obsFreq * ((float)

(freqRatio)) / ln2;

columnInfo += residueScore;

totalInformationContent += columnInfo;

(

<< totalInformationContent <<

);

(profileColumn=0; profileColumn<

; ++profileColumn) {

(maxVariety == minVariety)

scale = 1.0 - 1.0 * (varieties[profileColumn] - minVariety) / (maxVariety - minVariety);

(maxWeightedVariety == minWeightedVariety)

scale = 1.0 * (weightedVarieties[profileColumn] - minWeightedVariety) /

(maxWeightedVariety - minWeightedVariety);

minInform = 0.10f, maxInform = 6.24f;

scale = (informationContents[profileColumn] - minInform) / (maxInform - minInform);

(scale < 0.0) scale = 0.0;

(scale > 1.0) scale = 1.0;

(

);

ColumnProfile::iterator p, pe;

, profileColumn;

vector < CharIntMap > fitScores(

);

minFit=0, maxFit=0;

vector < float > FloatVector;

BlockRowScores blockFitScores, blockZFitScores, blockRowFitScores;

minBlockFit=0.0f, maxBlockFit=0.0f, minBlockZFit=0.0f, maxBlockZFit=0.0f, minBlockRowFit=0.0f, maxBlockRowFit=0.0f;

BlockMap::const_iterator

, be =

.end();

(

=

.begin();

!=be; ++

) {

blockFitScores[

->first].resize(

, 0.0f);

(

blockColumn=0; blockColumn<

->first->width; ++blockColumn) {

profileColumn =

->second[blockColumn];

(p=profile.begin(); p!=pe; ++p) {

& fit = fitScores[profileColumn][p->first];

->first->GetRangeOfRow(0)->from + blockColumn);

(blockColumn == 0 &&

==

.begin() && p == profile.begin()) {

minFit = maxFit = fit;

(fit < minFit) minFit = fit;

(fit > maxFit) maxFit = fit;

blockFitScores[

->first][

] += fitScores[profileColumn][ch];

average = 0.0f;

& score = blockFitScores[

->first][

];

score /=

->first->width;

minBlockFit = maxBlockFit = score;

(score < minBlockFit) minBlockFit = score;

(score > maxBlockFit) maxBlockFit = score;

stdDev += (blockFitScores[

->first][

] - average) *

(blockFitScores[

->first][

] - average);

stdDev = sqrt(stdDev);

(stdDev > 1e-10) {

blockZFitScores[

->first].resize(

);

blockZFitScores[

->first][

] = (blockFitScores[

->first][

] - average) / stdDev;

(

.size() >= 2) {

(

=

.begin();

!=be; ++

)

average = 0.0f;

(

=

.begin();

!=be; ++

)

average += blockFitScores[

->first][

];

average /=

.size();

(

=

.begin();

!=be; ++

)

stdDev += (blockFitScores[

->first][

] - average) *

(blockFitScores[

->first][

] - average);

stdDev /=

.size() - 1;

stdDev = sqrt(stdDev);

(stdDev > 1e-10) {

(

=

.begin();

!=be; ++

)

blockRowFitScores[

->first][

] = (blockFitScores[

->first][

] - average) / stdDev;

(profileColumn=0; profileColumn<

; ++profileColumn) {

CharIntMap::const_iterator c, ce = fitScores[profileColumn].end();

(c=fitScores[profileColumn].begin(); c!=ce; ++c) {

(maxFit == minFit)

scale = 1.0 * (c->second - minFit) / (maxFit - minFit);

(

=

.begin();

!=be; ++

) {

(maxBlockFit == minBlockFit)

scale = 1.0 * (blockFitScores[

->first][

] - minBlockFit) / (maxBlockFit - minBlockFit);

(

=

.begin();

!=be; ++

) {

(blockZFitScores.find(

->first) != blockZFitScores.end()) {

zScore = blockZFitScores[

->first][

];

minBlockZFit = maxBlockZFit = zScore;

(zScore < minBlockZFit) minBlockZFit = zScore;

(zScore > maxBlockZFit) maxBlockZFit = zScore;

(maxBlockZFit == minBlockZFit)

scale = 1.0 * (blockZFitScores[

->first][

] - minBlockZFit) /

(maxBlockZFit - minBlockZFit);

(

=

.begin();

!=be; ++

)

(

.size() >= 2) {

(blockRowFitScores.begin()->second[

] !=

) {

(

=

.begin();

!=be; ++

) {

zScore = blockRowFitScores[

->first][

];

minBlockRowFit = maxBlockRowFit = zScore;

(zScore < minBlockRowFit) minBlockRowFit = zScore;

(zScore > maxBlockRowFit) maxBlockRowFit = zScore;

(

=

.begin();

!=be; ++

) {

(maxBlockRowFit == minBlockRowFit)

scale = 1.0 * (blockRowFitScores[

->first][

] - minBlockRowFit) /

(maxBlockRowFit - minBlockRowFit);

*profileIndex,

*residue)

BlockMap::const_iterator

=

.find(block);

*profileIndex =

->second[blockColumn];

const BLAST_Matrix * GetPSSM(void) const

unsigned int NRows(void) const

bool IsFrom(const BlockMultipleAlignment *alignment) const

const Vector & Get(eColor which) const

void AddBlock(const UngappedAlignedBlock *block)

ColumnColors informationContentColors

ConservationColorer(const BlockMultipleAlignment *parent)

BlockFitColors blockRowFitColors

void GetProfileIndexAndResidue(const UngappedAlignedBlock *block, int blockColumn, int row, int *profileIndex, char *residue) const

ColumnColors weightedVarietyColors

ColumnColors varietyColors

AlignmentProfile alignmentProfile

std::map< char, int > ColumnProfile

BlockFitColors blockZFitColors

void CalculateFitConservationColors(void)

void CalculateBasicConservationColors(void)

std::vector< bool > identities

const BlockMultipleAlignment * alignment

BlockFitColors blockFitColors

const Colors * GlobalColors(void)

char ScreenResidueCharacter(char ch)

int GetBLOSUM62Score(char a, char b)

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.

const TYPE & Get(const CNamedParameterList *param)

const SNCBIPackedScoreMatrix NCBISM_Blosum62

void NCBISM_Unpack(const SNCBIPackedScoreMatrix *psm, SNCBIFullScoreMatrix *fsm)

Expand a packed score matrix into an unpacked one, which callers can proceed to index directly by sta...

#define row(bind, expected)

double GetStandardProbability(char ch)

unsigned char LookupNCBIStdaaNumberFromCharacter(char r)

char LookupCharacterFromNCBIStdaaNumber(unsigned char n)

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