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

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

NCBI C++ ToolKit: include/util/align_range_coll.hpp Source File

;

<

TAlnRange>

TAlignRangeVector::size_type

;

std::lower_bound(

(),

(),

.GetFirstFrom(), p);

(

.GetLength() > 0) {

(

.GetLength() > 0) {

(it_ins !=

()) {

(it_ins ==

()) {

pair<const_iterator, bool> res =

(pos);

res.second ? res.first :

.end();

b_contains = (it !=

() && it->GetFirstFrom() <= pos);

make_pair(it, b_contains);

std::lower_bound(

(),

(), pos, p);

std::upper_bound(

(),

(), pos, p);

()->GetFirstFrom();

TAlignRange::GetEmptyFrom();

()->GetFirstToOpen();

TAlignRange::GetEmptyToOpen();

()->GetFirstTo();

TAlignRange::GetEmptyTo();

()->GetFirstToOpen() - from;

pair<const_iterator, bool> res =

(pos);

(res.first !=

()) {

pos = res.first->GetFirstFrom();

(res.first !=

()) {

pos = res.first->GetFirstTo();

res.second ? res.first->GetSecondPosByFirstPos(pos)

(dir ==

) {

(dir !=

) {

res_pos =

.GetSecondFrom();

dist = res_pos - pos;

res_pos = it->GetSecondTo();

dist = pos - res_pos;

(dist > 0 && (min_dist == -1 || min_dist > dist)) {

(it_closest ==

()) ? -1 : it_closest->GetFirstPosBySecondPos(min_pos);

vector<bool>* dead =

;

range_size =

.size();

(

= range_size - 1;

> 0; --

) {

dead =

vector<bool>(range_size,

);

dead->reserve(range_size);

(*dead)[

] =

;

(

= 0;

< range_size;

++ ) {

(shift > 0) {

.resize(range_size - shift);

(

= 0;

<

.size()-1;

++) {

(

== complete) {

(r_left, r_right);

TAlignRangeVector::iterator

;

rg.SetFirstFrom(rg.GetFirstFrom()*3);

rg.SetSecondFrom(rg.GetSecondFrom()*3);

rg.SetLength(rg.GetLength()*3);

rg.SetFirstFrom(rg.GetFirstFrom()*3);

rg.SetSecondFrom(rg.GetSecondFrom()*3);

rg.SetLength(rg.GetLength()*3);

TAlignRangeVector::iterator it = ranges.begin();

(it != ranges.end()) {

(!it->IntersectingWith(range)) {

TAlignRangeVector::iterator del = it;

(it->GetFirstFrom() < range.

() || it->GetFirstTo() > range.

()) {

it->IntersectWith(range);

TAlignRangeVector::iterator it = ranges.begin();

(it != ranges.end()) {

(it->GetSecondTo() < range.

() || it->GetSecondFrom() > range.

()) {

TAlignRangeVector::iterator del = it;

(it->GetSecondFrom() < range.

() || it->GetSecondTo() > range.

()) {

it->IntersectSecondWith(range);

<

TAlnRange>

*

+= -

;

== iter.m_Iter;

!(*

== iter);

*

+= -

;

const_iterator

()

k1->GetFirstFrom() < k2->GetFirstFrom();

k1->GetFirstFrom() < pos;

pos < k2->GetFirstFrom();

k1->GetSecondFrom() < k2->GetSecondFrom();

k1->GetSecondFrom() < pos;

pos < k2->GetSecondFrom();

(

.GetLength() > 0) {

const_iterator it_ins =

();

(

.GetLength() > 0) {

it_left =

(it);

(it_left->IsAbutting(

)) {

.CombineWithAbutting(*it_left);

(it->IsAbutting(

)) {

.CombineWithAbutting(*it);

const_iterator

(const_iterator it_del)

const_iterator it_res =

();

(it_del != it_res) {

it_res =

(it_del);

pair<const_iterator, bool> res =

(pos);

res.second ? res.first :

();

b_contains = (it !=

() && it->GetFirstFrom() <= pos);

make_pair(it, b_contains);

res.second? res.first.first:

();

std::lower_bound(

(),

(), pos, p);

std::upper_bound(

(),

(), pos, p);

TAlignRange::GetEmptyFrom();

()->GetFirstFrom();

TAlignRange::GetEmptyToOpen();

()->GetFirstToOpen();

TAlignRange::GetEmptyTo();

()->GetFirstTo();

()->GetFirstToOpen() - from;

pair<const_iterator, bool> res =

(pos);

( !res.second ) {

( res.first !=

() ) {

pos = res.first->GetFirstFrom();

( res.first !=

() ) {

pos = res.first->GetFirstTo();

res.second ? res.first->GetSecondPosByFirstPos(pos)

( dir ==

) {

( dir ==

) {

const_iterator it_closest =

();

pair<pair<const_iterator, const_iterator>,

> res =

(pos);

( !res.second ) {

( res.first.first !=

() ) {

(

.GetSecondFrom() > pos);

it_closest = res.first.first;

min_pos =

.GetSecondFrom();

min_dist =

.GetSecondFrom() - pos;

( res.first.second !=

() ) {

dist = pos -

.GetSecondTo();

( min_dist < 0 || dist < min_dist ) {

it_closest = res.first.second;

min_pos =

.GetSecondTo();

( min_dist >= 0 ) {

it_closest = res.first.first;

min_dist >= 0? it_closest->GetFirstPosBySecondPos(pos): -1;

const_iterator it_closest =

();

(const_iterator it =

(); it !=

(); it++) {

(dir !=

) {

res_pos =

.GetSecondFrom();

dist = res_pos - pos;

res_pos = it->GetSecondTo();

dist = pos - res_pos;

(dist > 0 && (min_dist == -1 || min_dist > dist)) {

(it_closest ==

()) ? -1 : it_closest->GetFirstPosBySecondPos(min_pos);

(

== where ) {

= i_next, ++i_next ) {

(

->IsAbutting(*i_next) ) {

i_next->CombineWithAbutting(*

);

= i_next, ++i_next ) {

(

== complete) {

(r_left, r_right);

(

&

: insertions) {

(

&

: collection ) {

pos = iter->GetFirstFrom();

( *it == iter ) {

(0&&

);

pos = iter->GetSecondFrom();

( *it == iter ) {

(0&&

);

prev_iter =

(iter);

((*prev_iter)->GetFirstFrom() <= pos);

( (*prev_iter)->GetFirstToOpen() > pos ) {

pair<pair<const_iterator, const_iterator>,

>

pair<pair<const_iterator, const_iterator>,

> ret;

prev_iter =

(iter);

((*prev_iter)->GetSecondFrom() <= pos);

( (*prev_iter)->GetSecondToOpen() > pos ) {

ret.first.first = *prev_iter;

ret.first.second =

();

ret.first.second = *prev_iter;

ret.first.second =

();

ret.first.first = *iter;

ret.first.first =

();

rg.SetFirstFrom(rg.GetFirstFrom()*3);

rg.SetSecondFrom(rg.GetSecondFrom()*3);

rg.SetLength(rg.GetLength()*3);

rg.SetFirstFrom(rg.GetFirstFrom()*3);

rg.SetSecondFrom(rg.GetSecondFrom()*3);

rg.SetLength(rg.GetLength()*3);

rg.SetFirstFrom(rg.GetFirstFrom()*3);

rg.SetSecondFrom(rg.GetSecondFrom()*3);

rg.SetLength(rg.GetLength()*3);

<

TRanges>

TRanges::iterator it = ranges.begin();

(it != ranges.end()) {

(!it->IntersectingWith(range)) {

TRanges::iterator del = it;

(it->GetFirstFrom() < range.

() || it->GetFirstTo() > range.

()) {

it->IntersectWith(range);

<

TRanges>

TRanges::iterator it = ranges.begin();

(it != ranges.end()) {

(it->GetSecondTo() < range.

() || it->GetSecondFrom() > range.

()) {

TRanges::iterator del = it;

(it->GetSecondFrom() < range.

() || it->GetSecondTo() > range.

()) {

it->IntersectSecondWith(range);

<

TColl>

(

->GetSecondFrom(),

));

(

.GetSecondTo() >= pos);

.SecondContains(pos) ? it :

.

();

p.second->GetSecondTo() < pos;

pos < p.second->GetSecondTo();

p1.second->GetSecondTo() < p2.second->GetSecondTo();

<

TAlnRange>

m_Ranges.assign(src.

(), src.

());

vector< TRangeWithFuzz > TRanges

virtual const char * GetErrCodeString(void) const override

Get error code interpreted as text.

CAlignRangeCollException()

CAlignRangeCollExtender this is an adapter for a collection that perfroms some of the operations fast...

position_type GetSecondTo() const

position_type GetSecondToOpen() const

void Init(const TColl &coll)

CAlignRangeCollExtender(const TColl &coll)

multimap< position_type, const TAlignRange * > TFrom2Range

position_type GetSecondFrom() const

TColl::ESearchDirection TSearchDir

CRange< position_type > GetSecondRange() const

const_iterator FindOnSecond(position_type pos) const

finds a segment at logarithmic time (linear time on first call) returns an iterator to the fisrt segm...

const_iterator end() const

TFrom2Range::const_iterator const_iterator

TColl::position_type position_type

position_type GetSecondLength(void) const

TColl::TAlignRange TAlignRange

const_iterator begin() const

const_iterator operator++(int)

const_iterator & operator--()

pointer operator->() const

const_iterator operator+(int delta)

bidirectional_iterator_tag iterator_category

const_iterator(const TRawIterator &iter)

const TAlignRange * pointer

ptrdiff_t difference_type

const TAlignRange & reference

const_iterator operator-(int delta)

reference operator*() const

const_iterator & operator-=(int delta)

bool operator==(const const_iterator &iter) const

const_iterator & operator+=(int delta)

const_iterator & operator++()

const_iterator operator--(int)

bool operator!=(const const_iterator &iter) const

iterator & operator+=(int delta)

reference operator*() const

iterator operator-(int delta)

iterator(const TRawIterator &i)

iterator operator+(int delta)

pointer operator->() const

iterator & operator-=(int delta)

class CAlignRangeCollectionList<TAlignRange> represent a sorted collection of TAlignRange.

const_iterator find_insertion_point(const TAlignRange &range) const

bool IsSet(int flags) const

static int ValidateRanges(const TAlignRange &r_1, const TAlignRange &r_2)

determine conflicts between two ranges

int GetStateFlags() const

const_iterator x_FindRangeContaining(position_type pos) const

int GetPolicyFlags() const

TIndexBySecond m_IndexBySecond

CAlignRangeCollectionList(const TAlignRangeVectorImpl &v, int flags)

const_iterator begin() const

const_iterator insert(const TAlignRange &r)

ESearchDirection

adding empty ranges is considered valid, they are simply ignored

CAlignRangeCollectionList< TAlignRange > TThisType

void x_Unindex(TIndexKey iter)

const_iterator insert(const_iterator it, const TAlignRange &arg_r)

TAlignRangeVectorImpl m_RangesVector

void x_UnindexBySecond(TIndexKey iter)

const TAlignRange & operator[](size_type pos) const

Use iterator access.

void IntersectFirst(const CRange< position_type > &range)

list< TAlignRange > TAlignRangeList

pair< const_iterator, bool > find_2(position_type pos) const

returns an iterator pointing to a range containing "pos"; if such a range does not exists an iterator...

const_reverse_iterator rbegin() const

position_type GetFirstLength(void) const

TSignedSeqPos GetSecondPosByFirstPos(position_type pos, ESearchDirection dir=eNone) const

void IntersectSecond(const CRange< position_type > &range)

void Normalize()

ensures that segments are sorted, if fAllowAdjust is not set - merges adjacent segments

pair< pair< const_iterator, const_iterator >, bool > find_2_by_second(position_type pos) const

returns an iterator pointing to a range containing "pos"; if such a range does not exists an iterator...

void push_back(const TAlignRange &r)

void x_IntersectFirst(TRanges &ranges, const CRange< position_type > &range)

TAlignRangeList::size_type size_type

bool x_Equals(const TThisType &c) const

iterator x_FindInsertionPlace(const TAlignRange &r)

position_type GetFirstFrom() const

TAlignRangeList::const_reverse_iterator const_reverse_iterator

const TIndexByFirst & GetIndexByFirst() const

CRange< position_type > GetFirstRange() const

@ fMixedDir

contains at least one reversed range

@ fPolicyMask

Keep compatible with SC-8.0.

@ fNotValidated

State flags:

@ fAllowOverlap

allow segments with different orientation

@ fAllowAbutting

allow segments overlapping on the first sequence

@ fInvalid

collection was modified and not validated

@ fIgnoreInsertions

allows segments not separated by gaps

@ fAllowMixedDir

enforce all policies after any modification

@ fKeepNormalized

Policies:

@ fReversed

contains at least one direct range

@ fDefaultPolicy

do not store insertions

@ fUnsorted

one or more policies violated

TSignedSeqPos GetFirstPosBySecondPos(position_type pos, ESearchDirection dir=eNone) const

TAlignRangeList::iterator TRawIterator

CAlignRangeCollectionList(const TAlignRangeList &v, int flags)

const TIndexBySecond & GetIndexBySecond() const

const_iterator find(position_type pos) const

void x_SetFlags(int flags)

TIndexByFirst m_IndexByFirst

combination of EFlags

void CombineAbutting()

merge adjacent segments together, merging changes collection size and invalidates iterators

TAlignRangeList m_RangesList

const TInsertions & GetInsertions() const

Each insertion shows where the 'first' sequence has a gap while the 'second' sequence has the inserti...

void x_ResetFlags(int flags)

vector< TAlignRange > TInsertions

const_reverse_iterator rend() const

TRawIterator x_Insert(TRawIterator where, const TAlignRange &r)

void x_Erase(TRawIterator iter)

multiset< TIndexKey, PIndexBySecondLess > TIndexBySecond

void x_Index(TIndexKey iter)

const_iterator end() const

multiset< TIndexKey, PIndexByFirstLess > TIndexByFirst

vector< TAlignRange > TAlignRangeVector

position_type GetFirstTo() const

vector< TAlignRange > TAlignRangeVectorImpl

Use iterators on TAlignRangeList or TInsertions for insertions.

position_type GetFirstToOpen() const

void x_UnindexByFirst(TIndexKey iter)

const_iterator find_by_second(position_type pos) const

const_iterator erase(const_iterator it_del)

void x_MultiplyCoordsBy3()

void Validate()

analyses segements and updates flags

void AddInsertion(const TAlignRange &r)

TAlignRangeVectorImpl & x_GetAlignRangeVector() const

void x_IntersectSecond(TRanges &ranges, const CRange< position_type > &range)

TAlignRange::position_type position_type

void AddInsertions(const TInsertions &insertions)

void AddInsertions(const TThisType &collection)

CAlignRangeCollectionList(int flags=fDefaultPolicy)

pair< pair< const_iterator, const_iterator >, bool > x_FindRangesBySecondContaining(position_type pos) const

void SortInsertions(void)

class CAlignRangeCollection<TAlignRange> represent a sorted collection of TAlignRange.

position_type GetFirstTo() const

void Normalize()

ensures that segments are sorted, if fAllowAdjust is not set - merges adjacent segments

void x_IntersectSecond(TAlignRangeVector &ranges, const CRange< position_type > &range)

TAlignRangeVector m_Ranges

const_reverse_iterator rend() const

TAlignRangeVector::const_reverse_iterator const_reverse_iterator

TAlignRangeVector::const_iterator const_iterator

vector< TAlignRange > TAlignRangeVector

const_iterator insert(const_iterator where, const TAlignRange &r)

bool IsSet(int flags) const

CAlignRangeCollection(const TAlignRangeVector &v, int flags)

int GetPolicyFlags() const

void AddInsertions(const TThisType &collection)

TSignedSeqPos GetFirstPosBySecondPos(position_type pos, ESearchDirection dir=eNone) const

void push_back(const TAlignRange &r)

void CombineAbutting()

merge adjacent segments together, merging changes collection size and invalidates iterators

CRange< position_type > GetFirstRange() const

position_type GetFirstToOpen() const

const_iterator lower_bound(position_type pos) const

@ fAllowOverlap

allow segments with different orientation

@ fMixedDir

contains at least one reversed range

@ fPolicyMask

Keep compatible with SC-8.0.

@ fIgnoreInsertions

allows segments not separated by gaps

@ fAllowAbutting

allow segments overlapping on the first sequence

@ fAllowMixedDir

enforce all policies after any modification

@ fInvalid

collection was modified and not validated

@ fKeepNormalized

Policies:

@ fUnsorted

one or more policies violated

@ fDefaultPolicy

do not store insertions

@ fNotValidated

State flags:

@ fReversed

contains at least one direct range

void AddInsertions(const TAlignRangeVector &insertions)

position_type GetFirstFrom() const

void Validate()

analyses segements and updates flags

const_iterator insert(const TAlignRange &r)

void x_SetFlags(int flags)

const_iterator upper_bound(position_type pos) const

TSignedSeqPos GetSecondPosByFirstPos(position_type pos, ESearchDirection dir=eNone) const

const_iterator erase(const_iterator it)

bool x_Equals(const TThisType &c) const

void IntersectSecond(const CRange< position_type > &range)

const TAlignRange & operator[](size_type pos) const

position_type GetFirstLength(void) const

const_iterator find(position_type pos) const

void x_ResetFlags(int flags)

ESearchDirection

adding empty ranges is considered valid, they are simply ignored

CAlignRangeCollection(int flags=fDefaultPolicy)

void SortInsertions(void)

TAlignRange::position_type position_type

const_iterator end() const

TAlignRangeVector::iterator iterator

const_reverse_iterator rbegin() const

TAlignRangeVector m_Insertions

void AddInsertion(const TAlignRange &r)

int GetStateFlags() const

TAlignRangeVector::size_type size_type

void x_IntersectFirst(TAlignRangeVector &ranges, const CRange< position_type > &range)

void Assign(const CAlignRangeCollectionList< TAlignRange > &src)

pair< const_iterator, bool > find_2(position_type pos) const

returns an iterator pointing to a range containing "pos"; if such a range does not exists an iterator...

void x_MultiplyCoordsBy3()

CAlignRangeCollection< TAlignRange > TThisType

const TAlignRangeVector & GetInsertions() const

Each insertion shows where the 'first' sequence has a gap while the 'second' sequence has the inserti...

const_iterator begin() const

TAlignRangeVector::reverse_iterator reverse_iterator

const_iterator find_insertion_point(const TAlignRange &r)

static int ValidateRanges(const TAlignRange &r_1, const TAlignRange &r_2)

determine conflicts between two ranges

TAlignRange & operator[](size_type pos)

void IntersectFirst(const CRange< position_type > &range)

CAlignRange Represents an element of pairwise alignment of two sequences.

container_type::const_iterator const_iterator

const_iterator end() const

iterator insert(const value_type &val)

const_iterator begin() const

container_type::value_type value_type

const_iterator begin() const

const_iterator upper_bound(const key_type &key) const

iterator insert(const value_type &val)

const_iterator end() const

const_iterator lower_bound(const key_type &key) const

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

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

pair< TRange, CRef< CSeq_align > > TAlignRange

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

int TSignedSeqPos

Type for signed sequence position.

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

bool IsAbutting(const TThisType &r) const

position_type GetFirstToOpen(void) const

bool NotEmpty(void) const

TThisType & CombineWithAbutting(const TThisType &r)

position_type GetFirstFrom(void) 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.

constexpr auto sort(_Init &&init)

Defines NCBI C++ exception handling.

The NCBI C++/STL use hints.

Int4 delta(size_t dimension_, const Int4 *score_)

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

bool operator()(const typename TFrom2Range::value_type &p1, const typename TFrom2Range::value_type &p2)

TAlignRange::position_type position_type

bool operator()(const typename TFrom2Range::value_type &p, position_type pos)

bool operator()(position_type pos, const typename TFrom2Range::value_type &p)

bool operator()(position_type pos, const TIndexKey &k2) const

bool operator()(const TIndexKey &k1, const TIndexKey &k2) const

bool operator()(const TIndexKey &k1, position_type pos) const

bool operator()(position_type pos, const TIndexKey &k2) const

bool operator()(const TIndexKey &k1, const TIndexKey &k2) const

bool operator()(const TIndexKey &k1, position_type pos) const

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