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

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

NCBI C++ ToolKit: src/algo/align/mergetree/merge_tree.cpp Source File

AlignIds.

(EquivIter->AlignId);

MisMatches = 0;

Matches += EquivIter->Matches;

MisMatches += EquivIter->MisMatches;

MisMatches = 0;

Matches += EquivIter->Matches;

MisMatches += EquivIter->MisMatches;

Matches+MisMatches;

(

->GetSeqStart(0) !=

->GetSeqStart(0))

(

->GetSeqStart(0) <

->GetSeqStart(0));

(

->GetSeqStop(0) !=

->GetSeqStop(0))

(

->GetSeqStop(0) <

->GetSeqStop(0));

(

->GetSeqStart(1) !=

->GetSeqStart(1))

(

->GetSeqStart(1) <

->GetSeqStart(1));

(

->GetSeqStop(1) !=

->GetSeqStop(1))

(

->GetSeqStop(1) <

->GetSeqStop(1));

->GetSeqStrand(0) <

->GetSeqStrand(0);

(

->GetSeqStart(0) !=

->GetSeqStart(0))

(

->GetSeqStart(0) >

->GetSeqStart(0));

(

->GetSeqStop(0) !=

->GetSeqStop(0))

(

->GetSeqStop(0) >

->GetSeqStop(0));

(

->GetSeqStart(1) !=

->GetSeqStart(1))

(

->GetSeqStart(1) <

->GetSeqStart(1));

(

->GetSeqStop(1) !=

->GetSeqStop(1))

(

->GetSeqStop(1) <

->GetSeqStop(1));

->GetSeqStrand(0) <

->GetSeqStrand(0);

InterA =

(

.GetSeqStart(1)) -

(

.GetSeqStart(0));

InterA =

.GetSeqStop(1) +

.GetSeqStart(0);

(InterA < InterB);

(

->GetAlignLength(

) <

->GetAlignLength(

));

TEquivList::const_iterator AI, BI;

TEquivList::const_iterator AE, BE;

(AI == AE || BI == BE) {

(AI->Query == BI->Query && AI->Subjt == BI->Subjt) {

(AI->Query.GetFrom() < BI->Query.GetFrom()) {

cerr <<

<< *AI << endl;

(BI->Query.GetFrom() < AI->Query.GetFrom()) {

cerr <<

<< *BI << endl;

(AI->Subjt.GetFrom() < BI->Subjt.GetFrom()) {

cerr <<

<< *AI << endl;

(BI->Subjt.GetFrom() < AI->Subjt.GetFrom()) {

cerr <<

<< *BI << endl;

cerr <<

<< *AI << endl;

cerr <<

<< *BI << endl;

cerr <<

<< *AI << endl;

cerr <<

<< *BI << endl;

(

, DeltaInt);

(L=0; L < (

)

.size(); L++) {

CurrPath.push_back(

[L] );

CurrScore = Tree.

(CurrPath);

(CurrScore >= BestScore) {

BestScore = CurrScore;

(

=

;

>= 0;

--) {

CurrPath.insert(CurrPath.begin(),

[

]);

CurrScore = Tree.

(CurrPath);

(CurrScore >= BestScore) {

BestScore = CurrScore;

(

> 0 ||

< (

)(

.size()-1) ) {

cerr <<

<<

<<

<<

<<

<< BestScore <<

<<

.size()-1 << endl;

pair<CSeq_id_Handle, ENa_strand>

;

pair<TSeqIdPair, TSeqIdPair>

;

vector<CRef<CSeq_align> >

;

AlignMap[Key].push_back(*AlignIter);

(TAlignMap, MapIter, AlignMap) {

QueryBSH =

->GetBioseqHandle(QueryIDH);

SubjtBSH =

->GetBioseqHandle(SubjtIDH);

cerr << AID <<

<< (*AlignIter)->GetSeqRange(0)

<<

<< (*AlignIter)->GetSeqRange(1) << endl;

cerr <<

<< OrigEquivs.size() << endl;

(QueryBSH && SubjtBSH) {

EquivRangeBuilder.

(QueryBSH, SubjtBSH, OrigEquivs);

Iter->Matches = Iter->Query.GetLength();

Iter->MisMatches = 0;

CRangeCollection<TSeqPos> QRC, SRC;

CRangeCollection<TSeqPos> DQRC, DSRC;

ITERATE(TEquivList, Iter, OrigEquivs) {

if(QRC.IntersectingWith(Iter->Query)) {

CRangeCollection<TSeqPos> T(Iter->Query);

T.IntersectWith(QRC);

if(SRC.IntersectingWith(Iter->Subjt)) {

CRangeCollection<TSeqPos> T(Iter->Subjt);

T.IntersectWith(SRC);

CRangeCollection<TSeqPos> NQRC, NSRC;

NQRC += QRC.GetLimits();

NSRC += SRC.GetLimits();

vector<TSeqPos> RQs, RSs;

RQs.push_back(QRC.GetFrom());

ITERATE(CRangeCollection<TSeqPos>, Iter, NQRC) {

RQs.push_back(Iter->GetFrom());

RQs.push_back(Iter->GetTo());

cerr << "QZ: " << *Iter << endl;

RQs.push_back(QRC.GetTo()+1);

RSs.push_back(SRC.GetFrom());

ITERATE(CRangeCollection<TSeqPos>, Iter, NSRC) {

RSs.push_back(Iter->GetFrom());

RSs.push_back(Iter->GetTo());

cerr << "SZ: " << *Iter << endl;

RSs.push_back(SRC.GetTo()+1);

vector<TSeqPos>::iterator NE;

sort(RQs.begin(), RQs.end());

NE = unique(RQs.begin(), RQs.end());

RQs.erase(NE, RQs.end());

sort(RSs.begin(), RSs.end());

NE = unique(RSs.begin(), RSs.end());

RSs.erase(NE, RSs.end());

CMergeTree::SScoring QuadScoring;

QuadScoring.GapExtend = 0;

ITERATE(TEquivList, Iter, OrigEquivs) {

QR.CombineWith(Iter->Query);

SR.CombineWith(Iter->Subjt);

cerr << QR << "\t" << SR << endl;

CQuadTree QT(64, QR, SR);

QT.SetRecs(RQs, RSs);

ITERATE(TEquivList, Iter, OrigEquivs) {

int NodesVisited = 0;

NON_CONST_ITERATE(CQuadTree, QuadIter, QT) {

if(!QuadIter->IsLeaf)

if(QuadIter->Storage.empty())

set<int> AlignIds = s_AlignIdsFromEquivList(QuadIter->Storage);

cerr << QuadIter->XR << "\t" << QuadIter->YR

<< "\t" << QuadIter->Depth

<< "\t" << QuadIter->Storage.size()

<< "\t" << AlignIds.size()

<< "\t" << s_ScoreFromEquivList(QuadIter->Storage)

ITERATE(set<int>, AlignIdIter, AlignIds) {

cerr << "\t" << *AlignIdIter;

TEquivList LocalSplits;

EquivRangeBuilder.SplitIntersections(QuadIter->Storage, LocalSplits);

QuadIter->Storage.clear();

Tree.SetScoring(QuadScoring); //m_Scoring);

Tree.AddEquivs(LocalSplits);

cerr << "\t" << Path.size() << endl;

// CRef<CSeq_align> Merged;

// Merged = x_MakeSeqAlign(Path, QueryIDH, SubjtIDH);

// Output.push_back(Merged);

EquivRangeBuilder.MergeAbuttings(Path, QuadIter->Storage);

//QuadIter->Storage.insert(QuadIter->Storage.end(), Path.begin(), Path.end());

AlignIds = s_AlignIdsFromEquivList(QuadIter->Storage);

cerr << "\t" << QuadIter->Storage.size()

<< "\t" << AlignIds.size()

<< "\t" << s_ScoreFromEquivList(QuadIter->Storage)

ITERATE(set<int>, AlignIdIter, AlignIds) {

cerr << "\t" << *AlignIdIter;

cerr << "NodesVisited: " << NodesVisited << endl;

CRef<CSeq_align> Merged;

Merged = x_MakeSeqAlign(Path, QueryIDH, SubjtIDH);

Output.push_back(Merged);

ITERATE(TEquivList, PathIter, Path) {

AlignIds.insert(PathIter->AlignId);

cerr << "Aligns: " << AlignIds.size() << endl;

ITERATE(TEquivList, EraseIter, OrigEquivs) {

if( AlignIds.find(EraseIter->AlignId) != AlignIds.end()) {

Filtered.push_back(*EraseIter);

cerr << " Orig: " << OrigEquivs.size() << " Filt: " << Filtered.size() << endl;

OrigEquivs.swap(Filtered);

cerr << "_______________________________" << endl;

Output.push_back(Merged);

pair<CSeq_id_Handle, ENa_strand>

;

pair<TSeqIdPair, TSeqIdPair>

;

vector<CRef<CSeq_align> >

;

AlignMap[Key].push_back(*AlignIter);

(TAlignMap, MapIter, AlignMap) {

QueryBSH =

->GetBioseqHandle(QueryIDH);

SubjtBSH =

->GetBioseqHandle(SubjtIDH);

TAlignEquivListMap AlignEquivs;

(QueryBSH && SubjtBSH) {

EquivRangeBuilder.

(QueryBSH, SubjtBSH, Temp);

Iter->Matches = Iter->Query.GetLength();

Iter->MisMatches = 0;

AlignEquivs[AID].insert(AlignEquivs[AID].end(), Temp.begin(), Temp.end());

OrigEquivs.insert(OrigEquivs.end(), Temp.begin(), Temp.end());

cerr << AID <<

<< (*AlignIter)->GetSeqRange(0)

<<

<< (*AlignIter)->GetSeqRange(1) << endl;

cerr <<

<< OrigEquivs.size() << endl;

(QueryBSH && SubjtBSH) {

EquivRangeBuilder.

(QueryBSH, SubjtBSH, OrigEquivs);

Iter->Matches = Iter->Query.GetLength();

Iter->MisMatches = 0;

(

Loop = 0; Loop < 3; Loop++) {

(TAlignEquivListMap, OrigAlignIter, AlignEquivs) {

& CurrAlignEquivs = OrigAlignIter->second;

CurrEquivs.insert(CurrEquivs.end(), AccumEquivs.begin(), AccumEquivs.end());

CurrEquivs.insert(CurrEquivs.end(), CurrAlignEquivs.begin(), CurrAlignEquivs.end());

(AccumScore > NewScore)

cerr <<

<< endl;

AccumScore = NewScore;

(Abutted.begin(), Abutted.end());

AccumEquivs = Abutted;

cerr << __LINE__ <<

<< AccumEquivs.size()

<<

<< CurrAlignEquivs.size()

<<

<< SplitEquivs.size()

<<

<<

.size()

<<

<< Tree.

()

<<

<< Tree.

()<< endl;

Output.push_back(Merged);

<< MapIter->second.size() <<

<<endl;

QueryBSH =

->GetBioseqHandle(QueryIDH);

SubjtBSH =

->GetBioseqHandle(SubjtIDH);

(QueryBSH && SubjtBSH &&

QueryRange += (*AlignIter)->GetSeqRange(0);

SubjtRange += (*AlignIter)->GetSeqRange(1);

(QueryRange.

() >= QueryLen ||

SubjtRange.

() >= SubjtLen) {

cerr <<

<< QueryIDH.

() <<

<< SubjtIDH.

() << endl;

cerr <<

<< Aligns.size() <<

<< Unique.size() <<

<< Other.size() << endl;

(!Unique.empty()) {

list<CRef<CSeq_align> > Ins, Outs;

Ins.insert(Ins.end(), Unique.begin(), Unique.end());

cerr <<

<< Ins.size() <<

<< Outs.size() << endl;

Other.push_back(*OutIter);

QueryId->Assign(*QueryIDH.

());

Denseg.

().push_back(QueryId);

Denseg.

().push_back(SubjtId);

(EquivIter->Empty())

Denseg.

().push_back(EquivIter->Query.GetFrom());

Denseg.

().push_back(EquivIter->Subjt.GetFrom());

Denseg.

().push_back(EquivIter->Query.GetLength());

Denseg.

().push_back(EquivIter->Strand);

& DiscAlign = **DiscAlignIter;

AlignGroupMap[Key].push_back(*DiscAlignIter);

AlignGroupMap[Key].push_back(*AlignIter);

Intersected =

;

OuterRanges[] = { (*Outer)->GetSeqRange(0), (*Outer)->GetSeqRange(1) };

InnerRanges[] = { (*Inner)->GetSeqRange(0), (*Inner)->GetSeqRange(1) };

( OuterRanges[0].IntersectingWith(InnerRanges[0]) ||

OuterRanges[1].IntersectingWith(InnerRanges[1]) ) {

Other.push_back(*Outer);

Unique.push_back(*Outer);

= IndexIter->first;

OI = IndexIter->second;

cerr <<

<<

<<

<< OI <<

<<

<< endl;

cerr <<

<< MinI <<

<< MinD << endl;

cerr <<

<< AlignIter->first <<

<< AlignIter->second.size() << endl;

: m_EquivRangeBuilder(Original.m_EquivRangeBuilder), m_NextIndex(0)

NewAlignEquivs.

(), NewAlignEquivs.end());

BestI = NewI;

= IndexIter->first;

(CurrDist < BestD) {

= IndexIter->first;

First.

(First.end(), MinEs.begin(), MinEs.end());

Second.insert(Second.end(), OtherEs.begin(), OtherEs.end());

(NearestIter->second == MinI ||

NearestIter->second == OtherI) {

& MinEs = AlignIter->second;

LastEquivs.insert(LastEquivs.end(), MinEs.begin(), MinEs.end());

RemoveGroups[RemoveIter->AlignId].push_back(*RemoveIter);

CurrIndex = AlignIter->first;

(RemoveGroups.

(CurrEquivs.front().AlignId) == RemoveGroups.

()) {

& RemoveGroupEquivs = RemoveGroups[CurrEquivs.front().AlignId];

Origs.

(Origs.end(), CurrEquivs.begin(), CurrEquivs.end());

Origs.insert(Origs.end(), RemoveGroupEquivs.begin(), RemoveGroupEquivs.end());

(SplitIter->AlignId == RemoveIter->AlignId &&

SplitIter->SegmtId == RemoveIter->SegmtId) {

(SplitIter->IntersectingWith(*RemoveIter)) {

Remaining.push_back(*SplitIter);

(CurrEquivs.empty()) {

(NearestIter->second == RemoveGroupIter->first) {

vector<size_t> Indexes;

Indexes.push_back(AlignIter->first);

( OII = 0; OII < Indexes.size(); OII++) {

Found =

;

( III = OII+1; III < Indexes.size(); III++) {

(CurrDist < BestDist) {

BestDist = CurrDist;

Found =

;

CurrIndex = AlignIter->first;

(CurrIndex == CalcIndex)

(CurrDist < BestDist) {

BestDist = CurrDist;

Uniform =

;

(EquivIter->AlignId != Equivs.front().AlignId) {

Equivs.front().AlignId;

PASSES_BEFORE_EARLY_REMOVE = 5;

list<CRef<CSeq_align> > EarlyRemoves;

cerr <<

<< Aligns.size() << endl;

OrigMatches = 0, AllMergeMatches = 0;

(QueryBSH && SubjtBSH) {

EquivRangeBuilder.

(QueryBSH, SubjtBSH, Temp);

Iter->Matches = Iter->Query.GetLength();

Iter->MisMatches = 0;

OrigMatches += EquivIter->Matches;

pair<int, size_t> TAlignIdScorePair;

pair<TAlignIdScorePair,TAlignIdScorePair> TAlignIdScoreKey;

TMergeResultMap MergeResultMap;

ALL_MIN = 1;

ALL_OTHER = 2;

FULL_MERGE = 3;

MIXED = 4;

PassCounter = 0;

(!OriginalGraph.

()) {

cerr <<

<< CurrGraph.

() << endl;

(CurrGraph.

() > 1) {

cerr <<

<< CurrGraph.

() <<

<< PassCounter << endl;

(MinEs.empty() || OtherEs.empty()) {

(!OtherEs.empty())

TAlignIdScoreKey

;

cerr <<

<<

.first.first <<

<<

.first.second <<

<< MinEs.size()<< endl;

cerr <<

<<

.second.first <<

<<

.second.second <<

<< OtherEs.size()<< endl;

(

.first.first != -1 &&

.second.first != -1) {{

(MergeResultMap.find(

) != MergeResultMap.end()) {

MergeResult = MergeResultMap[

];

cerr <<

<< MergeResult << endl;

(MergeResult == FULL_MERGE) {

CachedPath.insert(CachedPath.end(), MinEs.begin(), MinEs.end());

CachedPath.insert(CachedPath.end(), OtherEs.begin(), OtherEs.end());

(CachedPath.begin(), CachedPath.end());

}

(MergeResult == ALL_MIN) {

}

(MergeResult == ALL_OTHER) {

CachedPath = OtherEs;

(CachedPath.empty()) {

CurrEquivs.insert(CurrEquivs.end(), MinEs.begin(), MinEs.end());

CurrEquivs.insert(CurrEquivs.end(), OtherEs.begin(), OtherEs.end());

(CurrEquivs.begin(), CurrEquivs.end());

cerr <<

<< CurrEquivs.size() <<

<< SplitEquivs.size() << endl;

(

.empty()) {

Output.insert(Output.end(), EarlyRemoves.begin(), EarlyRemoves.end());

(Abutted.begin(), Abutted.end());

(

.first.first != -1 &&

.second.first != -1) {{

cerr <<

<< ResultId <<

<< ResultLength <<

<< Abutted.size()<< endl;

MergeResult = 0;

(ResultId == -1 && ResultLength == (

.first.second+

.second.second)) {

MergeResult = FULL_MERGE;

}

(ResultId ==

.first.first && ResultLength ==

.first.second) {

MergeResult = ALL_MIN;

}

(ResultId ==

.second.first && ResultLength ==

.second.second) {

MergeResult = ALL_OTHER;

MergeResult = MIXED;

MergeResultMap[

] = MergeResult;

cerr <<

<< MergeResult << endl;

(Abutted.begin(), Abutted.end());

(!Abutted.empty()) {

cerr <<

<< MinEs.size() <<

<< OtherEs.size() << endl;

cerr <<

<< Abutted.size() << endl;

(!Abutted.empty() && PassCounter > PASSES_BEFORE_EARLY_REMOVE) {{

(ResultId != -1) {

( (Abutted.size() == MinEs.size() &&

ResultId == MinEId) ||

(Abutted.size() == OtherEs.size() &&

ResultId == OtherEId) ) {

(ResultId == MinEId) {

}

(ResultId == OtherEId) {

(LoserEs !=

) {

AllMergeMatches += EquivIter->Matches;

EarlyRemoves.push_back(Merged);

MinScore = Tree.

(MinEs);

OtherScore = Tree.

(OtherEs);

NewScore = Tree.

(Abutted);

(NewScore < MinScore || NewScore < OtherScore) {

cerr <<

<< endl;

(!CurrGraph.

()) {

AllMergeMatches += EquivIter->Matches;

(!LastEquivs.empty()) {

Output.push_back(Merged);

Output.insert(Output.end(), EarlyRemoves.begin(), EarlyRemoves.end());

cerr <<

<< OrigMatches <<

<< AllMergeMatches << endl;

(OrigMatches != AllMergeMatches)

cerr <<

<< endl;

void x_CalculateAllDistances()

CAlignDistGraph(CEquivRangeBuilder &Builder)

void AddAlignment(const TEquivList &NewAlignEquivs)

bool GetAndRemoveNearestPair(TEquivList &First, TEquivList &Second)

CEquivRangeBuilder & m_EquivRangeBuilder

void x_CalculateOneDistance(size_t CalcIndex)

void RemoveEquivs(const TEquivList &RemoveEquivs)

map< size_t, TSeqPos > TIndexDistMap

void CalculateAllDistances()

map< size_t, size_t > TIndexIndexMap

TIndexDistMap NearestDistMap

map< size_t, TEquivList > TAlignEquivListMap

TAlignEquivListMap AlignEquivMap

bool GetLastAlignEquivs(TEquivList &LastEquivs)

TIndexIndexMap NearestMap

CRef< CDense_seg > FillUnaligned() const

Create a new dense-seg with added all unaligned pieces (implicit inserts), if any,...

void Compact()

Join adjacent mergeable segments to create a more compact alignment.

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

overloaded Assign()

void CalcMatches(objects::CBioseq_Handle QueryHandle, objects::CBioseq_Handle SubjtHandle, TEquivList &Equivs)

bool MergeAbuttings(const TEquivList &Originals, TEquivList &Merges)

void ExtractRangesFromSeqAlign(const objects::CSeq_align &Alignment, TEquivList &Equivs)

bool SplitIntersections(const TEquivList &Originals, TEquivList &Splits)

static TSeqPos Distance(const CEquivRange &A, const CEquivRange &B)

int Score(const TEquivList &Path) const

void SetScoring(SScoring Scoring)

TInterruptFnPtr SetInterruptCallback(TInterruptFnPtr Callback, void *CallbackData)

void Search(TEquivList &Path, bool Once=false)

void AddEquivs(const TEquivList &Equivs)

const CSeq_id & GetSeq_id(TDim row) const

Get seq-id (the first one if segments have different ids).

ENa_strand GetSeqStrand(TDim row) const

Get strand (the first one if segments have different strands).

void Validate(bool full_test=false) const

pair< TSeqIdPair, TSeqIdPair > TMapKey

void x_SplitGlobalUnique(const TAlignVec &Input, TAlignVec &Unique, TAlignVec &Other)

void Merge(const list< CRef< objects::CSeq_align > > &Input, list< CRef< objects::CSeq_align > > &Output)

void x_MakeMergeableGroups(list< CRef< objects::CSeq_align > > Input, TAlignGroupMap &AlignGroupMap)

vector< CRef< objects::CSeq_align > > TAlignVec

void Merge_Dist(const list< CRef< objects::CSeq_align > > &Input, list< CRef< objects::CSeq_align > > &Output)

void Merge_Pairwise(const list< CRef< objects::CSeq_align > > &Input, list< CRef< objects::CSeq_align > > &Output)

CRef< objects::CSeq_align > x_MakeSeqAlign(TEquivList &Equivs, objects::CSeq_id_Handle QueryIDH, objects::CSeq_id_Handle SubjtIDH)

void Merge_AllAtOnce(const list< CRef< objects::CSeq_align > > &Input, list< CRef< objects::CSeq_align > > &Output)

CMergeTree::TInterruptFnPtr Callback

objects::CScope * m_Scope

pair< objects::CSeq_id_Handle, objects::ENa_strand > TSeqIdPair

CMergeTree::SScoring m_Scoring

void x_Merge_Dist_Impl(TAlignVec &Aligns, objects::CSeq_id_Handle QueryIDH, objects::CSeq_id_Handle SubjtIDH, objects::CBioseq_Handle QueryBSH, objects::CBioseq_Handle SubjtBSH, list< CRef< objects::CSeq_align > > &Output)

const_iterator begin() const

const_iterator end() const

iterator_bool insert(const value_type &val)

const_iterator find(const key_type &key) const

iterator_bool insert(const value_type &val)

bool s_SortEquivBySubjt(const CEquivRange &A, const CEquivRange &B)

vector< CEquivRange > TEquivList

string Path(const string &dir, const string &file)

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define ERASE_ITERATE(Type, Var, Cont)

Non-constant version with ability to erase current element, if container permits.

int TSignedSeqPos

Type for signed sequence position.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

#define ERR_POST(message)

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

void Error(CExceptionArgs_Base &args)

#define NCBI_THROW(exception_class, err_code, message)

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

string ReportAll(TDiagPostFlags flags=eDPF_Exception) const

Report all exceptions.

#define MSerial_AsnText

I/O stream manipulators –.

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

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

CConstRef< CSeq_id > GetSeqId(void) const

static CSeq_id_Handle GetHandle(const CSeq_id &id)

Normal way of getting a handle, works for any seq-id.

string AsString(void) const

bool CanGetInst_Length(void) const

TInst_Length GetInst_Length(void) const

TThisType IntersectionWith(const TThisType &r) const

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

TTo GetTo(void) const

Get the To member data.

TFrom GetFrom(void) const

Get the From member data.

TLens & SetLens(void)

Assign a value to Lens data member.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

void SetDim(TDim value)

Assign a value to Dim data member.

void SetType(TType value)

Assign a value to Type data member.

TStarts & SetStarts(void)

Assign a value to Starts data member.

TStrands & SetStrands(void)

Assign a value to Strands data member.

bool IsDisc(void) const

Check if variant Disc is selected.

void SetNumseg(TNumseg value)

Assign a value to Numseg data member.

TIds & SetIds(void)

Assign a value to Ids data member.

const TDisc & GetDisc(void) const

Get the variant data.

const Tdata & Get(void) const

Get the member data.

const TSegs & GetSegs(void) const

Get the Segs member data.

@ eType_partial

mapping pieces together

unsigned int

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

bool s_SortSeqAlignByQuery_Subjt(CRef< CSeq_align > A, CRef< CSeq_align > B)

void s_EquivDiff(const TEquivList &A, const TEquivList &B)

bool s_SortSeqAlignByIntercept(CRef< CSeq_align > A, CRef< CSeq_align > B)

bool s_SortSeqAlignByLength(CRef< CSeq_align > A, CRef< CSeq_align > B)

TSeqPos s_AlignDist(const CSeq_align &A, const CSeq_align &B)

set< int > s_AlignIdsFromEquivList(const TEquivList &Equivs)

TSignedSeqPos s_SeqAlignIntercept(const CSeq_align &A)

bool s_SortSeqAlignByQueryMinus_Subjt(CRef< CSeq_align > A, CRef< CSeq_align > B)

size_t s_LengthFromEquivList(const TEquivList &Equivs)

size_t s_ScoreFromEquivList(const TEquivList &Equivs)

int s_UniformAlignId(const TEquivList &Equivs)

void s_FindBestSubRange(const CMergeTree &Tree, const TEquivList &Path)

constexpr auto sort(_Init &&init)

const struct ncbi::grid::netcache::search::fields::KEY key

#define F(x)

Make a parametrized function appear to have only one variable.

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