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

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

NCBI C++ ToolKit: include/algo/gnomon/debruijn/DBGraph.hpp Source File

<

T1,

T2,

T3,

T4,

T5>

{

variant<vector<pair<T1,size_t>>, vector<pair<T2,size_t>>, vector<pair<T3,size_t>>, vector<pair<T4,size_t>>, vector<pair<T5,size_t>> >

;

apply_visitor(container_size(),

);

cerr <<

<< endl;

cerr <<

<< endl;

apply_visitor(extract_uniq(min_count),

,

.m_container);

cerr <<

<< endl;

runtime_error(

);

pair_t::first_type large_t;

it = lower_bound(v.begin(), v.end(),

.

<large_t>(), [](

pair_t& element,

large_t& target){ return element.first < target; });

(it == v.end() || it->first !=

.

<large_t>())

container_size :

static_visitor<size_t> {

<

T>

(

& v)

{

v.size();} };

container_capacity :

static_visitor<size_t> {

<

T>

(

& v)

{

v.capacity();} };

element_size :

static_visitor<size_t> {

<

T>

(

& v)

{

(

);} };

clear :

static_visitor<> {

<

T>

(

& v)

{ v.clear();} };

T::value_type::first_type large_t;

v.push_back(make_pair(

.

<large_t>(),

));

<

T>

(

&

,

&

)

{

.insert(

.end(),

.begin(),

.end()); }

<

T,

U>

(

&

,

&

)

{ cerr <<

<< endl;

(1); }

merged.reserve(

.size()+

.size());

merge(

.begin(),

.end(),

.begin(),

.end(), back_inserter(merged));

<

T,

U>

(

&

,

&

)

{ cerr <<

<< endl;

(1); }

container_sort :

static_visitor<> {

<

T>

(

& v)

{

(v.begin(), v.end()); }};

<

T,

U>

(

&

,

&

)

{ cerr <<

<< endl;

(1); }

:

static_visitor<> {

T::iterator iter_t;

iter_t nextp = v.begin();

(iter_t

= v.begin();

!= v.end(); ) {

(++

!= v.end() && workp->first ==

->first)

workp->second +=

->second;

v.erase(nextp, v.end());

(

.empty())

;

(

= 1;

<

.size(); ++

) {

.push_back(

[0]);

(

= 1;

<

.size(); ++

) {

(

.back().first <

[

].first) {

.push_back(

[

]);

.back().second +=

[

].second;

<

T,

U>

(

&

,

&

)

{ cerr <<

<< endl;

(1); }

:

static_visitor<> {

num = v.size();

.write(

*

(&num),

num);

.write(

*

(&v[0]), num*

(v[0]));

:

static_visitor<> {

.read(

*

(&num),

num);

.read(

*

(&v[0]), num*

(v[0]));

<

T1,

T2,

T3,

T4,

T5,

V>

{

<

T>

(

& kmer)

{

kmer.oahash(); }

variant<unordered_map<T1,V,kmer_hash>, unordered_map<T2,V,kmer_hash>, unordered_map<T3,V,kmer_hash>, unordered_map<T4,V,kmer_hash>, unordered_map<T5,V,kmer_hash>>

;

cerr <<

<< endl;

runtime_error(

);

:

static_visitor<size_t> {

<

T>

(

& v)

{

v.size();} };

:

static_visitor<V&> {

T::key_type large_t;

v[

.

<large_t>()];

:

static_visitor<V*> {

T::key_type large_t;

T::iterator it = v.find(

.

<large_t>());

&(it->second);

<

V>

vector<pair<int,size_t>>

;

peak =

(rlimit,(

)bins.size()-SLOPE_LEN-1);

(peak >= SLOPE_LEN) {

(

= 1;

<= SLOPE_LEN && maxim; ++

)

maxim = bins[peak+

].second < bins[peak].second;

(

= 1;

<= SLOPE_LEN && maxim; ++

)

maxim = bins[peak-

].second < bins[peak].second;

(peak < SLOPE_LEN)

(

= 1;

<= peak; ++

) {

(bins[

].second < bins[valley].second)

(

= valley;

< (

)bins.size(); ++

) {

(bins[

].second > bins[peak].second)

(bins[valley].second < 0.7*bins[peak].second)

MIN_NUM = 100;

(

& bin : bins) {

(bin.second >= MIN_NUM)

gsize += bin.first*bin.second;

(

& bin : bins) {

gs += bin.first*bin.second;

(

=

(0, v);

<= rl; ++

)

+= bins[

].second;

((v >= 0 &&

> genome) ||

> 10*genome) {

make_pair(valley, rlimit);

<

T>

.read(

*

(&bin_num),

bin_num);

(

= 0;

< bin_num; ++

) {

pair<int, size_t> bin;

.read(

*

(&bin),

bin);

(index ==

() ? 0 : 2*(index+1));

(index ==

() ? 0 : 2*(index+1)+1);

(kmer_seq.find_first_not_of(

) != string::npos || (

)kmer_seq.size() !=

())

kmer(kmer_seq);

(plusf,1-plusf);

vector<Successor> successors;

bitset<4> branches(node%2 ? (branch_info >> 4) : branch_info);

(branches.count()) {

(

nt = 0; nt < 4; ++nt) {

node = (node%2 == 0 ? node+1 : node-1);

[

.first].first;

(

= (

)read.size()-1;

>= 0; --

) {

shift = (shift+2)%64;

(

num = nextp/64; num > 0; --num)

num +=

-kmer_len+1;

(

xx)

{

(read_length.begin(), read_length.end());

(

j = (

)read_length.size()-1; j >= 0 &&

< xx*

; --j) {

nxx = read_length[j];

+= read_length[j];

()

{

(0.5); }

(

= 0;

< read_length; ++

) {

reverse(read.begin(), read.end());

read_len = is.

();

bit_to = bit_from+2*read_len;

<

Dest>

(

bit_from,

bit_to, Dest& destination,

destination_bit_from,

destination_size)

{

(bit_to <= bit_from)

word = bit_from/64;

last_word = (bit_to-1)/64;

shift = bit_from%64;

destination_word = destination_bit_from/64;

destination_shift = destination_bit_from%64;

(destination_shift > 0) {

destination[destination_word] += (chunk << destination_shift);

(shift <= destination_shift)

(shift < destination_shift && destination_word < destination_size)

destination[destination_word] += (chunk >> (64-destination_shift));

destination[destination_word] = chunk;

destination_shift = (destination_shift+64-shift)%64;

( ; word <= last_word; ++word, ++destination_word) {

(destination_shift > 0) {

destination[destination_word] += (

[word] << destination_shift);

(destination_word+1 < destination_size)

destination[destination_word+1] += (

[word] >> (64-destination_shift));

destination[destination_word] =

[word];

partial_bits = (destination_bit_from+bit_to-bit_from)%64;

(partial_bits > 0) {

destination[destination_size-1] &=

;

deque<CDBGraph::Successor>

;

(s.size() <

) {

(successors.empty())

node = successors[0].m_node;

s.push_back(successors[0].m_nt);

s(1, base.

);

(s.size() <

) {

(successors.size() != 1)

node = successors[0].m_node;

s.push_back(successors[0].m_nt);

(successors.size() > 1) {

(

& suc : successors) {

successors.pop_back();

(

j = 0; target < 0 && j < (

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

(target >= 0 &&

(successors[target].m_node)) {

(

j = 0; j < (

)successors.size(); ) {

successors.erase(successors.begin()+j);

(

j = 0; target < 0 && j < (

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

(target >= 0 &&

(successors[target].m_node)) {

(

j = 0; j < (

)successors.size(); ) {

successors.erase(successors.begin()+j);

has_both =

;

(

j = 0; !has_both && j < (

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

minusf = 1.- plusf;

has_both =

(successors[j].m_node) && (

(plusf,minusf) > 0.25);

(

j = 0; j < (

)successors.size(); ) {

minusf = 1.- plusf;

(

(plusf,minusf) < fraction*

(plusf,minusf))

successors.erase(successors.begin()+j);

deque<SElement> storage;

unordered_map<CDBGraph::Node,SElement*> TElementMap;

TElementMap current_elements;

(

& suc : successors) {

storage.push_back(

(suc, 0));

current_elements[suc.m_node] = &storage.back();

list<SElement> connections;

(

step = 1; step < steps && !current_elements.empty(); ++step) {

TElementMap new_elements;

(

& el : current_elements) {

(el.second == 0) {

(

& suc : successors) {

new_elements[suc.m_node] = 0;

(suc.m_node == last_node) {

(

& suc : successors) {

storage.push_back(

(suc, el.second));

(suc.m_node == last_node) {

(!connections.empty()) {

connections.push_back(storage.back());

pair<TElementMap::iterator, bool> rslt = new_elements.insert(make_pair(suc.m_node, &storage.back()));

(!rslt.second || !

(suc.m_node))

rslt.first->second = 0;

(current_elements, new_elements);

(connections.empty())

bases.first.push_front(el.

);

bases.first.push_front(el.

);

unordered_map<CDBGraph::Node, tuple<TSeqList::iterator, bool>>

;

(

&

: branch) {

(successors.empty()) {

sequences.erase(get<0>(

.second));

(

= successors.size()-1;

>= 0; --

) {

TSeqList::iterator is = get<0>(

.second);

sequences.push_front(*is);

is = sequences.begin();

& bases = get<0>(*is);

& abundance = get<1>(*is);

bases.push_back(successors[

]);

pair<TBranch::iterator, bool> rslt = new_branch.insert(make_pair(node, make_tuple(is, get<1>(

.second))));

get<1>(rslt.first->second) =

;

TSeqList::iterator& js = get<0>(rslt.first->second);

(abundance > get<1>(*js)) {

sequences.erase(js);

sequences.erase(is);

(branch, new_branch);

(vector<CDBGraph::Successor>& successors,

max_extent,

min_extent) {

(max_extent == 0)

(

& suc : successors) {

extensions[suc.m_node] = make_tuple(sequences.begin(),

);

(!extensions.empty() && extensions.size() <

) {

TSeqList::iterator is = get<0>(extensions.begin()->second);

= get<0>(*is).size();

(

== max_extent)

(extensions.empty())

(extensions.size() == 1 &&

+1 >= min_extent)

(extensions.size() == 1 && !get<1>(extensions.begin()->second)) {

TSeqList::iterator is = get<0>(extensions.begin()->second);

& bases = get<0>(*is);

all_good =

;

(

& base : bases) {

max_extent =

;

(successors.empty())

(successors.size() > 1) {

step =

(successors, max_extent, 0);

step.push_back(successors.front());

all_good =

;

(

& s : step) {

step_size = step.size();

(predecessors.empty())

(predecessors.size() > 1 || step_size > 1)

step_back =

(predecessors, max_extent, step_size);

step_back.push_back(predecessors.front());

step_back_size = step_back.size();

(step_back_size < step_size)

(

= 0;

<= step_size-2 && good; ++

)

overshoot = step_back_size-step_size;

(overshoot > 0) {

(oversuc.empty())

(oversuc.size() > 1 || overshoot > 1)

step_over =

(oversuc, max_extent, overshoot);

step_over.push_back(oversuc.front());

((

)step_over.size() < overshoot)

(

= 0;

< overshoot && good; ++

)

(

& s : step) {

make_pair(extension, s.m_node);

extension.push_back(s);

node = extension.back().m_node;

make_pair(extension, 0);

(

& base : to_left) {

.push_back(initial_node);

ikmer = graph.

(initial_node);

.insert(

.end(), ikmer.begin(), ikmer.end());

(

& base : to_right) {

.push_back(base.m_nt);

.push_back(base.m_node);

kmer = graph.

(takeoff_node);

.insert(

.end(), kmer.begin()+1, kmer.end());

(

& base : extension) {

.push_back(base.m_nt);

.push_back(base.m_node);

(

= 0;

<

.size(); ++

) {

(minkmer && minkmer%2)

pair<TBases, CDBGraph::Node> to_right =

(initial_node);

(!to_left.second && !to_right.second && (

)(to_left.first.size()+

.

()+to_right.first.size()) < min_len) {

(

& base : to_right.first)

(

& base : to_left.first)

Entry point class for large integer usage.

std::array< const char, 4 > bin2NT

ncbi::TMaskedQueryRegions mask

string MostLikelySeq(CDBGraph::Successor base, unsigned len) const

tuple< TBases, size_t > TSequence

list< SContig > TContigList

tuple< TStrList::iterator, int > TContigEnd

string StringentExtension(CDBGraph::Node node, unsigned len) const

TBases JumpOver(vector< CDBGraph::Successor > &successors, int max_extent, int min_extent)

deque< CDBGraph::Successor > TBases

unordered_map< CDBGraph::Node, tuple< TSeqList::iterator, bool > > TBranch

SContig GetContigForKmerMT(CDBGraph::Node initial_node, int min_len)

pair< TBases, EConnectionStatus > ConnectTwoNodes(const CDBGraph::Node &first_node, const CDBGraph::Node &last_node, int steps) const

void OneStepBranchExtend(TBranch &branch, TSeqList &sequences)

bool GoodNode(const CDBGraph::Node &node) const

string MostLikelyExtension(CDBGraph::Node node, unsigned len) const

list< TSequence > TSeqList

pair< TBases, CDBGraph::Node > ExtendToRightMT(const CDBGraph::Node &initial_node)

void FilterNeighbors(vector< CDBGraph::Successor > &successors) const

CDBGraphDigger(CDBGraph &graph, double fraction, int jump, int low_count)

Node GetNode(const string &kmer_seq) const

bool GraphIsStranded() const

int Abundance(const Node &node) const

double MinFraction(const Node &node) const

bool ClearVisited(const Node &node)

CDBGraph(const TKmerCount &kmers, const TBins &bins, bool is_stranded)

Node GetNode(const TKmer &kmer) const

static Node ReverseComplement(Node node)

vector< Successor > GetNodeSuccessors(const Node &node) const

size_t ElementSize() const

string GetNodeSeq(const Node &node) const

vector< SAtomic< uint8_t > > m_visited

bool SetVisited(const Node &node, uint8_t value=1, uint8_t expected=0)

double PlusFraction(const Node &node) const

TKmer GetNodeKmer(const Node &node) const

int HistogramMinimum() const

uint8_t IsVisited(const Node &node) const

size_t Find(const TKmer &kmer) const

void PushBackElementsFrom(const CKmerCountTemplate &other)

variant< vector< pair< T1, size_t > >, vector< pair< T2, size_t > >, vector< pair< T3, size_t > >, vector< pair< T4, size_t > >, vector< pair< T5, size_t > > > Type

void Save(ostream &out) const

void Swap(CKmerCountTemplate &other)

void MergeTwoSorted(const CKmerCountTemplate &other)

void SortAndExtractUniq(int min_count, CKmerCountTemplate &uniq)

void Reserve(size_t rsrv)

size_t GetCount(size_t index) const

size_t ElementSize() const

CKmerCountTemplate(int kmer_len=0)

void SortAndUniq(int min_count)

pair< TKmer, size_t > GetKmerCount(size_t index) const

void PushBack(const TKmer &kmer, size_t count)

void UpdateCount(size_t count, size_t index)

V * Find(const TKmer &kmer)

V & operator[](const TKmer &kmer)

void Reserve(size_t rsrv)

variant< unordered_map< T1, V, kmer_hash >, unordered_map< T2, V, kmer_hash >, unordered_map< T3, V, kmer_hash >, unordered_map< T4, V, kmer_hash >, unordered_map< T5, V, kmer_hash > > Type

CKmerMapTemplate(int kmer_len=0)

kmer_iterator(int kmer_len, const CReadHolder &rholder, size_t position=0, size_t position_in_read=0, size_t read=0)

kmer_iterator & operator++()

friend bool operator!=(kmer_iterator const &li, kmer_iterator const &ri)

const CReadHolder & m_readholder

friend bool operator==(kmer_iterator const &li, kmer_iterator const &ri)

uint32_t m_position_in_read

friend bool operator==(string_iterator const &li, string_iterator const &ri)

friend bool operator!=(string_iterator const &li, string_iterator const &ri)

kmer_iterator KmersForRead(int kmer_len) const

string_iterator & operator++()

string_iterator(const CReadHolder &rholder, size_t position=0, size_t read=0)

const CReadHolder & m_readholder

kmer_iterator kbegin(int kmer_len) const

size_t KmerNum(unsigned kmer_len) const

void PushBack(const string &read)

kmer_iterator kend() const

deque< uint64_t > m_storage

void CopyBits(size_t bit_from, size_t bit_to, Dest &destination, size_t destination_bit_from, size_t destination_size) const

void Swap(CReadHolder &other)

void PushBack(const string_iterator &is)

deque< uint32_t > m_read_length

string_iterator sbegin() const

size_t NXX(double xx) const

string_iterator send() const

const U & get() const

Get the value of the IntegerTemplate object as a U type, U being one of the T1,T2,...

std::string toString(size_t sizeKmer) const

Get an ASCII string representation of a kmer encoded as a IntegerTemplate object.

void * getPointer()

Get pointer to the actual data - used for EMPHF.

std::ofstream out("events_result.xml")

main entry point for tests

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

static const char * expected[]

TResidue Complement(TResidue c)

void ReverseComplement(const BidirectionalIterator &first, const BidirectionalIterator &last)

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

unsigned int

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

IntegerTemplate< LargeInt< 1 >, LargeInt< 2 >, LargeInt< 4 >, LargeInt< 8 >, LargeInt< 16 > > TKmer

vector< pair< int, size_t > > TBins

pair< int, int > HistogramRange(const TBins &bins)

CKmerCountTemplate< LargeInt< 1 >, LargeInt< 2 >, LargeInt< 4 >, LargeInt< 8 >, LargeInt< 16 > > TKmerCount

LargeInt< precision > revcomp(const LargeInt< precision > &x, size_t sizeKmer)

int FindValleyAndPeak(const TBins &bins, int rlimit)

constexpr auto sort(_Init &&init)

constexpr auto rotate(list< Ts... >) -> decltype((list<>{}+...+rotate_item< Ts >{}))

double value_type

The numeric datatype used by the parser.

const GenericPointer< typename T::ValueType > T2 value

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

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

static SLJIT_INLINE sljit_ins l(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

SContig(const string &contig, CDBGraph &graph)

size_t MinKmerPosition() const

SContig(SContig *link, int shift, CDBGraph::Node takeoff_node, const TBases &extension, CDBGraph::Node rnode, const CDBGraph &graph)

bool operator<(const SContig &other) const

SAtomic< uint8_t > m_is_taken

void AddToRight(const SContig &other)

deque< CDBGraph::Node > m_kmers

void RotateCircularToMinKmer()

SContig(const TBases &to_left, const TBases &to_right, CDBGraph::Node initial_node, CDBGraph::Node lnode, CDBGraph::Node rnode, const CDBGraph &graph)

CDBGraph::Node m_next_left

CDBGraph::Node m_next_right

void SelectMinDirection()

void AddToLeft(const SContig &other)

CDBGraph::Successor m_suc

SElement(CDBGraph::Successor suc, SElement *link)

Successor(const Node &node, char c)

void operator()(T &v) const

size_t operator()(const T &v) const

size_t operator()(const T &v) const

void operator()(T &v) const

size_t operator()(const T &v) const

size_t operator()(const T &v) const

find_kmer(const TKmer &k)

size_t operator()(T &v) const

pair< TKmer, size_t > operator()(T &v) const

void operator()(T &v) const

void operator()(T &a, const T &b) const

void operator()(T &a, const T &b) const

push_back(const TKmer &k, size_t c)

void operator()(T &v) const

void operator()(T &v) const

void operator()(T &v) const

void operator()(T &a, T &b) const

void operator()(T &v) const

void operator()(T &v) const

update_count(size_t c, size_t i)

size_t operator()(const T &v) const

V * operator()(T &v) const

size_t operator()(const T &kmer) const

V & operator()(T &v) const

void operator()(T &v) const

SAtomic(const SAtomic &other)

bool Set(T value, T expected=0)

SAtomic(const atomic< T > &a)

SAtomic & operator=(const SAtomic &other)

int g(Seg_Gsm *spe, Seq_Mtf *psm, Thd_Gsm *tdg)

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