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

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

NCBI C++ ToolKit: src/algo/cobalt/prog.cpp Source File

(!constraint.empty()) {

= constraint.size();

(constraint[

-4] >= (

)seq1_start ||

constraint[

-2] >= (

)seq2_start) {

constraint.push_back(seq1_start);

constraint.push_back(seq1_start);

constraint.push_back(seq2_start);

constraint.push_back(seq2_start);

(seq1_start >= seq1_stop ||

seq2_start >= seq2_stop)

constraint.push_back(seq1_stop);

constraint.push_back(seq1_stop);

constraint.push_back(seq2_stop);

constraint.push_back(seq2_stop);

vector<CSequence>& query_data,

vector<CTree::STreeLeaf>& node_list,

(range.GetFrom() < 0 || range.GetTo() >= range.GetFrom());

(

= 0;

< node_list.size();

++) {

sum += node_list[

].distance;

(

= 0;

< node_list.size();

++) {

index = node_list[

].query_idx;

= node_list[

].distance / sum;

(node_list[

].distance == 0 && sum == 0)

= node_list[

].distance / sum;

start = range.GetFrom() >= 0 ? range.GetFrom() : 0;

= range.GetFrom() >= 0 ? range.GetTo() - range.GetFrom() + 1

: query_data[index].GetLength();

(

j = 0; j <

; j++) {

freq_data[j][0] +=

;

freq_data[j][k] +=

* matrix(start + j, k);

(

= 0;

< freq_size;

++) {

sum += freq_data[

][j];

freq_data[

][j] *= sum;

(;

< seq.

() && s < seq_pos;

++) {

{

< p.first && second < p.second;}

vector<CMultiAligner::TRangePair>& prof_ranges)

(p.first >= 0 && p.second >= 0);

(p.first < 0 || p.second < 0) {

.first.SetFrom(p.first);

.second.SetFrom(p.second);

(p <

&& s < end_seq) {

(p <

&& s < end_seq

((p.first >=

.first && s.first < end_seq.first)

|| (p.second >=

.second && s.second < end_seq.second)) {

.first.SetTo(p.first - 1);

.second.SetTo(p.second - 1);

(

.first.GetLength() ==

.second.GetLength());

prof_ranges.push_back(

);

(p.first <

.first

(p.second <

.second

.first.SetFrom(p.first);

.second.SetFrom(p.second);

(

= 0;

<

;

++) {

(

++;

<

;

++) {

vector<CSequence>& alignment,

vector<CTree::STreeLeaf>& node_list1,

vector<CTree::STreeLeaf>& node_list2,

kMinAlignLength = 11;

(

= 0;

< (

)node_list1.size();

++) {

(

j = 0; j < (

)node_list2.size(); j++) {

seq1 = node_list1[

].query_idx;

seq2 = node_list2[j].query_idx;

(

k = 0; k < pair_info(seq1, seq2).Size(); k++) {

*hit = pair_info(seq1, seq2).GetHit(k);

*new_hit =

(seq1, seq2);

*subhit = *subitr;

*new_subhit =

(seq1, seq2);

);

(profile_hitlist.

())

(

= 0;

< profile_hitlist.

();

++) {

*subhit = *subitr;

);

printf(

);

(

= 0;

< profile_hitlist.

();

++) {

printf(

,

vector<SGraphNode> graph;

(

j = 0; j < profile_hitlist.

(); j++) {

(iteration == 0 && hit->

< 1000 &&

(

= 0;

< (

)graph.size();

++) {

*ghit = graph[

].hit;

graph[

].hit = hit;

(

== (

)graph.size())

);

(iteration == 0) {

num_hits = profile_hitlist.

();

vector<int> list1, list2;

list1.reserve(num_hits);

list2.reserve(num_hits);

(

= 0;

< (

)graph.size();

++) {

*ghit = graph[

].hit;

(

j = 0; j < num_hits; j++) {

(k = 0; k < (

)list1.size(); k++) {

(k == (

)list1.size())

(k = 0; k < (

)list2.size(); k++) {

(k == (

)list2.size())

graph[

].best_score = graph[

].hit->

*

list1.size() * list2.size();

);

itr->best_score = itr->hit->m_Score;

(best_path != 0) {

printf(

,

vector<CTree::STreeLeaf>& node_list1,

vector<CTree::STreeLeaf>& node_list2,

vector<TRangePair>& match_ranges)

seq1 = -1, seq2 = -1;

(

=0;

< node_list1.size();

++) {

(

j=0;j < node_list2.size();j++) {

(dist > dmat(node_list1[

].query_idx, node_list2[j].query_idx)

seq1 = node_list1[

].query_idx;

seq2 = node_list2[j].query_idx;

dist = dmat(seq1, seq2);

(pair_info(seq1, seq2).Size() == 0) {

* hit = pair_info(seq1, seq2).GetHit(0);

(

k=1;k < pair_info(seq1, seq2).Size();k++) {

(pair_info(seq1, seq2).GetHit(k)->m_Score > hit->

) {

hit = pair_info(seq1, seq2).GetHit(k);

vector<TOffsetPair> seq_match_regions(

(seq_match_regions.size() >= 2);

(

=0;

< seq_match_regions.size();

+=2) {

(

< seq_match_regions.size() - 1);

== seq_match_regions[

+ 1].second - seq_match_regions[

].second);

seq_match_regions[

+ 1].

);

seq_range2(seq_match_regions[

].second,

seq_match_regions[

+ 1].second);

printf(

);

printf(

,

match_ranges.front().first.GetFrom(),

match_ranges.back().first.GetTo(),

match_ranges.front().second.GetFrom(),

match_ranges.back().second.GetTo(),

vector<CTree::STreeLeaf>& node_list1,

vector<CTree::STreeLeaf>& node_list2,

vector<CSequence>& alignment,

freq1_size = alignment[node_list1[0].query_idx].GetLength();

freq2_size = alignment[node_list2[0].query_idx].GetLength();

printf(

,

freq1_size, freq2_size);

freq1_data =

* [freq1_size];

(

= 1;

< freq1_size;

++)

memset(freq1_data[0], 0,

* freq1_size *

(

));

freq2_data =

* [freq2_size];

(

= 1;

< freq2_size;

++)

memset(freq2_data[0], 0,

* freq2_size *

(

));

(

**)freq2_data, freq2_size,

);

vector<size_t> constraint;

node_list2, pair_info, iteration);

printf(

);

(

= 0;

< (

)constraint.size();

+=4) {

printf(

, (

)constraint[

],

(

)constraint[

+2]);

(freq1_size > 1.2 * freq2_size ||

freq2_size > 1.2 * freq1_size) {

((freq1_size > 1.5 * freq2_size ||

freq2_size > 1.5 * freq1_size) &&

!constraint.empty()) {

[] freq1_data[0];

[] freq1_data;

[] freq2_data[0];

[] freq2_data;

(

= 0;

< (

)node_list1.size();

++) {

alignment[node_list1[

].query_idx].PropagateGaps(

,

(

= 0;

< (

)node_list2.size();

++) {

alignment[node_list2[

].query_idx].PropagateGaps(

,

(

= 0;

< (

)

.size() / 10;

++)

printf(

,

+ 1);

(

= 0;

< (

)

.size();

++)

printf(

,

% 10);

(

= 0;

< (

)node_list1.size();

++) {

index = node_list1[

].query_idx;

printf(

, index);

(

j = 0; j <

.GetLength(); j++) {

printf(

,

.GetPrintableLetter(j));

(

= 0;

< (

)node_list2.size();

++) {

index = node_list2[

].query_idx;

printf(

, index);

(

j = 0; j <

.GetLength(); j++) {

printf(

,

.GetPrintableLetter(j));

vector<CTree::STreeLeaf>& node_list1,

vector<CTree::STreeLeaf>& node_list2,

vector<CSequence>& alignment,

vector<size_t>& constraints,

full_prof_len1,

full_prof_len2,

freq1_size = range1.

() - range1.

() + 1;

freq2_size = range2.

() - range2.

() + 1;

freq1_data =

* [freq1_size];

(

= 1;

< freq1_size;

++)

memset(freq1_data[0], 0,

* freq1_size *

(

));

freq2_data =

* [freq2_size];

(

= 1;

< freq2_size;

++) {

memset(freq2_data[0], 0,

* freq2_size *

(

));

(

**)freq2_data, freq2_size,

);

(full_prof_len1 > 1.2 * full_prof_len2 ||

full_prof_len2 > 1.2 * full_prof_len1) {

[] freq1_data[0];

[] freq1_data;

[] freq2_data[0];

[] freq2_data;

vector<CTree::STreeLeaf>& node_list1,

vector<CTree::STreeLeaf>& node_list2,

vector<CSequence>& alignment,

printf(

,

alignment[node_list1[0].query_idx].

(),

alignment[node_list2[0].query_idx].

());

vector<TRangePair> match_ranges;

pair_info, match_ranges);

(match_ranges.empty()) {

message =

;

(vector<CTree::STreeLeaf>, it, node_list1) {

message +=

;

(vector<CTree::STreeLeaf>, it, node_list2) {

message +=

;

(vector<TRangePair>, rit, match_ranges) {

printf(

,

rit->first.GetFrom(), rit->second.GetFrom(),

rit->first.GetTo(), rit->second.GetTo());

prof1_length = alignment[node_list1.front().query_idx].GetLength();

prof2_length = alignment[node_list2.front().query_idx].GetLength();

(match_ranges.front().first.GetFrom() > 0

&& match_ranges.front().second.GetFrom() > 0) {

range1(0, match_ranges.front().first.GetFrom() - 1);

range2(0, match_ranges.front().second.GetFrom() - 1);

vector<size_t> constr;

constr, range1, range2,

len1 = match_ranges.front().first.GetFrom();

len2 = match_ranges.front().second.GetFrom();

(

=0;

< len1;

++) {

(

=0;

< len2;

++) {

vector<TRangePair>::const_iterator it(match_ranges.begin());

(

=0;

< it->first.GetLength();

++) {

vector<TRangePair>::const_iterator prev_it(it);

(; it != match_ranges.end(); ++it, ++prev_it) {

(it->first.GetLength() == it->second.GetLength());

space1(prev_it->first.GetToOpen(), it->first.GetFrom() - 1);

space2(prev_it->second.GetToOpen(), it->second.GetFrom() - 1);

(space1.

()) {

(space2.

()) {

vector<size_t> constr;

transcr.push_back(*

);

(

=0;

< it->first.GetLength();

++) {

(prof1_length - match_ranges.back().first.GetTo() - 1 > 0

&& prof2_length - match_ranges.back().second.GetTo() - 1 > 0) {

seq1_range(match_ranges.back().first.GetTo() + 1,

seq2_range(match_ranges.back().second.GetTo() + 1,

vector<size_t> constr;

constr, seq1_range, seq2_range,

prof1_length, prof2_length,

transcr.push_back(*it);

len1 = prof1_length - match_ranges.back().first.GetTo() - 1;

len2 = prof2_length - match_ranges.back().second.GetTo() - 1;

(

=0;

< len1;

++) {

(

=0;

< len2;

++) {

(

=0;

< (

)node_list1.size();

++) {

alignment[node_list1[

].query_idx].PropagateGaps(transcr,

(

=0;

< (

)node_list2.size();

++) {

alignment[node_list2[

].query_idx].PropagateGaps(transcr,

(

= 0;

< (

)

.size() / 10;

++)

printf(

,

+ 1);

(

= 0;

< (

)

.size();

++)

printf(

,

% 10);

(

= 0;

< (

)node_list1.size();

++) {

index = node_list1[

].query_idx;

printf(

, index);

(

j = 0; j <

.GetLength(); j++) {

printf(

,

.GetPrintableLetter(j));

(

= 0;

< (

)node_list2.size();

++) {

index = node_list2[

].query_idx;

printf(

, index);

(

j = 0; j <

.GetLength(); j++) {

printf(

,

.GetPrintableLetter(j));

0.000000, 0.019250, 0.073770, 0.052030, 0.228450,

0.084020, 0.021990, 0.207660, 0.108730, 0.204100

0, 7, 9, 1, 9, 9, 5, 2, 6, 4, 8, 4, 4,

9, 3, 9, 8, 7, 7, 4, 5, 0, 5, 9, 0, 0

num_queries = align.size();

= 1.0 / num_queries;

(

j = 0; j < num_queries; j++)

freq[j] =

[j] *

;

H1 += freq[j] *

((num_queries - 1) / pseudocount +

H1 - H2 *

((num_queries - 1) *

(pseudocount + H3) / pseudocount);

align_len = align[0].GetLength();

(

= 0;

< align_len;

++)

vector<CSequence>& alignment,

vector<CTree::STreeLeaf> full_seq_list;

vector<CTree::STreeLeaf> cluster_seq_list;

printf(

);

(

= 0;

< (

)cluster_seq_list.size();

++) {

printf(

, cluster_seq_list[

].query_idx);

vector<int> cluster_idx;

vector<int> other_idx;

vector<CTree::STreeLeaf> other_seq_list;

cluster_size = cluster_seq_list.size();

(

= 0;

< num_queries;

++) {

(j = 0; j < cluster_size; j++) {

(full_seq_list[

].query_idx ==

cluster_seq_list[j].query_idx) {

(j == cluster_size) {

other_seq_list.push_back(full_seq_list[

]);

other_idx.push_back(full_seq_list[

].query_idx);

(

= 0;

< cluster_size;

++) {

cluster_idx.push_back(cluster_seq_list[

].query_idx);

vector<CSequence> tmp_align = alignment;

tmp_align, pair_info, iteration);

printf(

, new_score);

(new_score > score) {

alignment.swap(tmp_align);

vector<CSequence>& query_data,

vector<TRange>& gaps)

gaps.push_back(range);

vector<CSequence>& query_data,

iteration,

is_cluster)

(!left_child->

())

pair_info, iteration, is_cluster);

(!right_child->

())

pair_info, iteration, is_cluster);

vector<CTree::STreeLeaf> node_list1, node_list2;

left_child->

().GetDist());

right_child->

().GetDist());

(is_cluster && iteration == 0) {

query_data, pair_info, iteration);

query_data, pair_info, iteration);

);

vector<TRange> gaps;

vector<CSequence>& query_data,

vector<TRange>& gaps)

vector<TRange>::const_iterator gap_it(gaps.begin());

(

=it->GetFrom();i < it->GetTo();

++) {

(gap_it != gaps.end() && gap_it->GetFrom() <

+

) {

+= gap_it->GetTo() - gap_it->GetFrom() + 1;

(

j=0;j < (

)matrix.

();j++) {

(rps_freqs(

, j) >= 0.0);

matrix(

+

, j) = rps_freqs(

, j);

-= domain_res_freq_boost;

+= domain_res_freq_boost;

vector<CSequence>& new_alignment,

num_queries = new_alignment.size();

align_length = new_alignment[0].GetLength();

vector<double> hvec(align_length);

vector<TRange> chosen_cols;

(

= 0;

< align_length;

++) {

(

= 0;

< align_length;

++) {

(!chosen_cols.empty() &&

chosen_cols.back().GetTo() ==

-1) {

chosen_cols.back().SetTo(

);

chosen_cols.push_back(

(

,

));

(

= j = 0; j < (

)chosen_cols.size(); j++) {

chosen_cols[

++] = chosen_cols[j];

chosen_cols.resize(

);

(

= 0;

< (

)chosen_cols.size();

++) {

printf(

,

chosen_cols[

].GetFrom(), chosen_cols[

].GetTo());

vector<TRange> range_nogap(num_queries);

(

= 0;

< (

)chosen_cols.size();

++) {

& curr_range = chosen_cols[

];

start = curr_range.

();

(j = 0; j < num_queries; j++) {

(k = 0; k < length; k++) {

range_nogap[j].SetEmpty();

(m = 0; m <= curr_range.

(); m++) {

offset2 = offset1;

(; m <= curr_range.

(); m++) {

range_nogap[j].Set(offset1, offset2);

(k = 0; k < num_queries - 1; k++) {

(m = k + 1; m < num_queries; m++) {

(!range_nogap[k].

() && !range_nogap[m].Empty()) {

range_nogap[m], 1000,

printf(

);

(

= 0;

< align_length;

++) {

printf(

, hvec[

]);

((

+1)%10 == 0)

(

= 0;

< num_queries;

++) {

(

j = 0; j < num_queries; j++) {

pair_info(

, j).ResetList();

vector<CTree::STreeEdge>& edges,

cluster_cutoff)

new_conserved_cols;

new_score = 0.0;

pair_info, iteration,

);

realign_score =

(tmp_aligned);

printf(

, realign_score);

(

= 0;

< num_tries;

++) {

new_score = realign_score;

(

j = 0; j < (

)edges.size() &&

edges[j].distance >= cluster_cutoff; j++) {

(new_score - realign_score <= 0.02 *

(realign_score)) {

realign_score = new_score;

realign_score =

(realign_score, new_score);

(

= 0;

< num_queries;

++) {

(

j = 0; j < (

)tmp_aligned[

].

(); j++) {

printf(

, tmp_aligned[

].GetPrintableLetter(j));

printf(

, realign_score);

(realign_score > best_score) {

printf(

);

best_score = realign_score;

&& iteration >= 1) {

(

= 0;

< num_queries;

++) {

(

j = 0; j < num_queries; j++) {

pair_info(

, j).ResetList();

new_conserved_cols = 0;

(

= 0;

< conserved_regions.

();

++) {

(new_conserved_cols <= conserved_cols)

conserved_cols = new_conserved_cols;

pair_info, iteration,

);

(std::bad_alloc ex) {

.distance >

.distance;

vector<CTree::STreeEdge> edges;

num_edges = edges.size();

num_internal_edges =

(11, (

)(0.3 * num_edges + 0.5));

(

= 0;

< num_internal_edges - 1;

++) {

(edges[

].distance > 2 * edges[

+1].distance) {

cluster_cutoff = edges[

].distance;

(

== num_internal_edges - 1) {

cluster_cutoff = edges[

].distance;

(

= 0;

< num_edges;

++)

printf(

, edges[

].distance);

printf(

, cluster_cutoff);

static const string kScale

static const int kAlphabetSize

The aligner internally works only with the ncbistdaa alphabet.

CLocalRange< TOffset > TRange

define for the fundamental building block of sequence ranges

pair< TOffset, TOffset > TOffsetPair

Basic type specifying a range on a sequence.

int GetPrototype(void) const

Get cluster prototype.

const TDistMatrix & GetDistMatrix(void) const

Get distance matrix.

const TClusters & GetClusters(void) const

Get clusters.

Interface for the traceback from blast hits.

vector< TOffsetPair > ListMatchRegions(TOffsetPair start_offsets)

Compile a list of regions in the current edit script that contain substitutions.

An ordered collection of CHit objects.

int Size() const

Retrieve number of hits in list.

void PurgeAllHits()

Delete all hits unconditionally.

bool Empty()

Determine whether a list contains no hits.

CHit * GetHit(int index)

Retrieve a hit from the hitlist.

void SortByStartOffset()

Sort the hits in the hitlist by increasing sequence1 index, then by increasing sequence1 start offset...

void AddToHitList(CHit *hit)

Append a hit to the hitlist.

A generalized representation of a pairwise alignment.

TSubHit & GetSubHit()

Retrieve a list of subhits.

void InsertSubHit(CHit *hit)

Add a to a CHit's list of subhits.

int m_Score

Score of alignment.

CEditScript & GetEditScript()

Retrieve the traceback associated with a CHit.

int m_SeqIndex1

Numerical identifier for first sequence in alignment.

int m_SeqIndex2

Numerical identifier for second sequence in alignment.

TRange m_SeqRange1

The range of offsets on the first sequence.

TRange m_SeqRange2

The range of offsets on the second sequence.

bool HasSubHits()

Query if a CHit has a hierarchy of subhits available.

vector< CHit * > TSubHit

Hits can be grouped hierarchically.

A pair of integers, defined to privide increment and less-then operators.

bool operator<(const CIntPair &p) const

True if each element of this is smaller than the corresponding element of p.

CIntPair & operator++(void)

Increment both elements.

CIntPair operator++(int)

Increment both elements.

bool StrictlyBelow(const TThisType &r)

Test whether 'this' represents a sequence range strictly less than a given sequence range.

bool GetFastAlign(void) const

Check if fast alignment is to be used.

TScore GetEndGapExtendPenalty(void) const

Get gap extension penalty for end gaps in pairwise global alignment of profiles.

double GetConservedCutoffScore(void) const

Get cutoff score for conserved aligned columns.

bool GetIterate(void) const

Check if iterative alignmnet option is used.

double GetPseudocount(void) const

Get pseudocount for calculating column entropy.

TScore GetGapExtendPenalty(void) const

Get gap extension penlaty for middle gaps in pairwise global alignment of profiles.

TScore GetGapOpenPenalty(void) const

Get gap opening penalty for middle gaps in pairwise global alignment of profiles.

TScore GetEndGapOpenPenalty(void) const

Get gap opening penalty for end gaps in pairwise global alignment of profiles.

bool GetRealign(void) const

Check if MSA is to be realigned for different rooting of progressive alignment tree.

@ eMulti

Alignment guide tree for each cluster is attached to the main alignment guide tree.

bool GetVerbose(void) const

Get verbose mode.

double GetDomainResFreqBoost(void) const

Get boost for residue frequencies in conserved domains from RPS data base.

EEndGapCostStrategy

Strategy for reducing end gap penalties for profile-profile alignment.

@ fReduceLeft

Reduce penalty only for left end gaps.

@ fReduceBoth

Reduce penalty for both end gaps.

@ fReduceRight

Reduce penalty only for right end gaps.

CMultiAlignerOptions::EInClustAlnMethod m_ClustAlnMethod

SProgress m_ProgressMonitor

SGraphNode * x_FindBestPath(vector< SGraphNode > &nodes)

Find a maximum weight path in a directed acyclic graph.

void x_AlignProfileProfileUsingHit(vector< CTree::STreeLeaf > &node_list1, vector< CTree::STreeLeaf > &node_list2, vector< CSequence > &alignment, CNcbiMatrix< CHitList > &pair_info, int iteration)

Align two profiles with all sequences that belong to the same cluster.

void x_AddRpsFreqsToCluster(const CClusterer::CSingleCluster &cluster, vector< CSequence > &query_data, const vector< TRange > &gaps)

void x_BuildAlignmentIterative(vector< CTree::STreeEdge > &edges, double cluster_cutoff)

Main driver for the progressive alignment process.

CHitList m_LocalInClusterHits

void x_FindConservedColumns(vector< CSequence > &new_alignment, CHitList &conserved)

Create a list of constraints that reflect conserved columns in a multiple alignment.

const TPhyTreeNode * GetTree(void) const

Get ree used guide in progressive alignment.

@ eOutOfMemory

Out of memory error.

@ eInterrupt

Alignment interruped through callback function.

vector< CSequence > m_QueryData

void x_FindInClusterConstraints(vector< CSequence > &alignment, vector< CTree::STreeLeaf > &node_list1, vector< CTree::STreeLeaf > &node_list2, CNcbiMatrix< CHitList > &pair_info, vector< TRangePair > &match_ranges) const

Find constraint to use for profile to profile alignment in clusters.

vector< vector< TRange > > m_RPSLocs

void x_ComputeProfileRangeAlignment(vector< CTree::STreeLeaf > &node_list1, vector< CTree::STreeLeaf > &node_list2, vector< CSequence > &alignment, vector< size_t > &constraints, const TRange &range1, const TRange &range2, int full_prof_len1, int full_prof_len2, EEndGapCostStrategy strat, CNWAligner::TTranscript &t)

Compute profile profile alignmnet for a ranges of given profiles.

vector< CSequence > m_Results

CConstRef< CMultiAlignerOptions > m_Options

void x_AlignProfileProfile(vector< CTree::STreeLeaf > &node_list1, vector< CTree::STreeLeaf > &node_list2, vector< CSequence > &alignment, CNcbiMatrix< CHitList > &pair_info, int iteration)

Align two collections of sequences.

double x_GetScoreOneCol(vector< CSequence > &align, int col)

Calculate the entropy score of one column of a multiple alignment (see the COBALT papaer for details)

vector< string > m_Messages

void x_AlignProgressive(const TPhyTreeNode *tree, vector< CSequence > &query_data, CNcbiMatrix< CHitList > &pair_info, int iteration, bool is_cluster)

Main driver for progressive alignment.

int m_Score

Alignment score.

void x_BuildAlignment()

Given the current domain, local, pattern and user hits, along with the current tree,...

void x_FindConstraints(vector< size_t > &constraint, vector< CSequence > &alignment, vector< CTree::STreeLeaf > &node_list1, vector< CTree::STreeLeaf > &node_list2, CNcbiMatrix< CHitList > &pair_info, int iteration)

Find the set of constraints to use for a profile-profile alignment.

pair< TRange, TRange > TRangePair

double x_GetScore(vector< CSequence > &align)

Compute the entropy score of a multiple alignment.

static const int kRpsScaleFactor

static const int kClusterNodeId

double x_RealignSequences(const TPhyTreeNode *input_cluster, vector< CSequence > &alignment, CNcbiMatrix< CHitList > &pair_info, double score, int iteration)

Perform a single bipartition on a multiple alignment.

size_t GetRows() const

get the number of rows in this matrix

size_t GetCols() const

get the number of columns in this matrix

Class for representing protein sequences.

int GetLength() const

Get the length of the current sequence.

unsigned char GetLetter(int pos) const

Access the sequence letter at a specified position.

TFreqMatrix & GetFreqs()

Access the list of position frequencies associated with a sequence.

static void CompressSequences(vector< CSequence > &seq, vector< int > index_list)

Given a collection of sequences, remove all sequence positions where a subset of the sequences all co...

static const unsigned char kGapChar

The ncbistdaa code for a gap.

definition of a Culling tree

static void ListTreeEdges(const TPhyTreeNode *node, vector< STreeEdge > &edge_list, int max_id=-1)

Traverse a tree below a given starting point, listing all edges encountered along the way.

static void ListTreeLeaves(const TPhyTreeNode *node, vector< STreeLeaf > &node_list, double curr_dist=0)

Traverse a tree below a given starting point, listing all leaves encountered along the way.

Callback for sorting tree edges in order of decreasing edge weight.

bool operator()(const CTree::STreeEdge &a, const CTree::STreeEdge &b) const

Interface for CMultiAligner.

bool Empty(const CNcbiOstrstream &src)

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

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

void SetStartWg(TScore value)

TTranscript GetTranscript(bool reversed=true) const

void SetEndWs(TScore value)

virtual CNWAligner::TScore Run(void)

void SetEndWg(TScore value)

vector< ETranscriptSymbol > TTranscript

void SetSequences(const char *seq1, size_t len1, const char *seq2, size_t len2, bool verify=true)

void SetPattern(const vector< size_t > &pattern)

void SetEndSpaceFree(bool Left1, bool Right1, bool Left2, bool Right2)

void SetStartWs(TScore value)

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

TSeqPos GetLength(const CSeq_id &id, CScope *scope)

Get sequence length if scope not null, else return max possible TSeqPos.

position_type GetLength(void) const

bool NotEmpty(void) const

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

TNodeList::const_iterator TNodeList_CI

bool IsLeaf() const

Report whether this is a leaf node.

const TValue & GetValue(void) const

Return node's value.

void SetFrom(TFrom value)

Assign a value to From data member.

TTo GetTo(void) const

Get the To member data.

TFrom GetFrom(void) const

Get the From member data.

void SetTo(TTo value)

Assign a value to To data member.

unsigned int

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

constexpr auto sort(_Init &&init)

const struct ncbi::grid::netcache::search::fields::SIZE size

#define INT4_MAX

largest nubmer represented by signed int

#define INT4_MIN

Smallest (most negative) number represented by signed int.

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

static const int kNumClasses

Number of 'letters' in the reduced alphabet.

static void x_NormalizeResidueFrequencies(double **freq_data, int freq_size)

Normalize the residue frequencies so that each column sums to 1.0.

static void x_HitToConstraints(vector< size_t > &constraint, CHit *hit)

Convert a constraint into a form usable by CPSSMAligner.

static void x_AddConstraint(vector< size_t > &constraint, CHit *hit)

Convert one hit into a constraint usable by CPSSMAligner.

static void x_ExpandRange(TRange &range, CSequence &seq)

Convert a sequence range to reflect gaps added to the underlying sequence.

static void s_CleanUpConstraints(CNcbiMatrix< CHitList > &pair_info, int num_queries)

static const int kRes2Class[kAlphabetSize]

Mapping from protein letters to reduced alphabet letters.

static void x_GetProfileMatchRanges(const TRange &seq_range1, const TRange seq_range2, CSequence &seq1, CSequence &seq2, vector< CMultiAligner::TRangePair > &prof_ranges)

Translate ungapped alignment range for pair-wise sequence alignment in input sequence coordinates int...

static void x_FillResidueFrequencies(double **freq_data, vector< CSequence > &query_data, vector< CTree::STreeLeaf > &node_list, TRange range=TRange(-1, -1))

Compute the residue frequencies for a specified range of a collection of sequences.

static const double kDerivedFreqs[kNumClasses]

Background frequencies of the letters in the reduced alphabet (each is the sum of the Robinson-Robins...

static int s_SeqToProfilePosition(int seq_pos, CSequence &seq)

Find a profile position for a input sequence position.

static void x_GetClusterGapLocations(const CClusterer::CSingleCluster &cluster, const vector< CSequence > &query_data, vector< TRange > &gaps)

Find locations of gaps in cluster prototype.

struct SGraphNode * path_next

the optimal path node belongs to

CHit * hit

the alignment represented by this node

Structure for listing tree edges.

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