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

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

NCBI C++ ToolKit: src/algo/align/splign/compart_matching.cpp Source File

kNrMersTotal (1 << (kNr * 2));

kRepeatsPercentile (0.995);

*kFileExt_Masked =

;

*kFileExt_Remap =

;

*kFileExt_Offsets =

;

*kFileExt_Positions =

;

kUI8_LoWord (0xFFFFFFFF);

kUI8_LoByte (kUI8_LoWord >> 24);

kUI8_HiWord (kUI8_LoWord << 32);

kUI8_LoFive (kUI8_LoWord | (kUI8_LoWord << 8));

kUI8_LoHalfWordEachByte ((

(0x0F0F0F0F) << 32) | 0x0F0F0F0F);

kUI4_Lo28 (0xFFFFFFFF >> 4);

kUI8_SeqDb_lo (0x03030303);

kUI8_SeqDb ((kUI8_SeqDb_lo << 32) | kUI8_SeqDb_lo);

kMapGran (512 * 1024 * 1024);

0: rv =

;

;

1: rv =

;

;

2: rv =

;

;

3: rv =

;

;

<

T>

GetBinString(

v)

bitdim (

(

) * 8);

(

(0);

< bitdim; ++

) {

(

(bitdim);

> 0; --

) {

(

< bitdim &&

% 8 == 0) {

reported_len (-1);

(

attempt(0); attempt < 1; ++attempt) {

(reported_len >= 0 &&

(reported_len) == len_bytes) {

(reported_len < 0) {

ostr <<

<< filename

<<

<< reported_len <<

;

ostr <<

<< filename <<

<< reported_len <<

<<

<< len_bytes <<

;

ostr <<

;

<

T>

(

(0), imax (4*

(

)); i < imax; ++i, v >>= 2) {

rv = (rv << 2) | (v & 3);

<

T>

(

(1);

< 0xFF; ++

) {

(

(0), imax(

(

));

< imax; ++

) {

kMaxTwoBaseContent (14);

vector<Uint4> counts(4, 0);

(

k = 0; k < 14; ++k) {

++counts[0x00000003 &

];

ag (counts[0] + counts[1]);

at (counts[0] + counts[2]);

ac (counts[0] + counts[3]);

(counts[1] + counts[2]);

gc (counts[1] + counts[3]);

tc (counts[2] + counts[3]);

ag >= kMaxTwoBaseContent || at >= kMaxTwoBaseContent ||

ac >= kMaxTwoBaseContent ||

>= kMaxTwoBaseContent ||

gc >= kMaxTwoBaseContent || tc >= kMaxTwoBaseContent;

dir, base, ext;

(

& extended_name,

& new_ext)

dir, base, ext;

<

VectorT>

len_bytes (v.size() *

(TElem));

tempcgrfile (filename.c_str(), IOS_BASE::binary);

tempcgrfile.write((

* ) & v.front(), len_bytes);

<

VectorT>

tempcgrfile (filename.c_str(), IOS_BASE::binary);

tempcgrfile.read((

* ) & v.front(), dim *

(TElem));

sfx (

(strand?

:

) +

);

mask_ofs_q (

+ sfx + kFileExt_Offsets);

filename ((*ii)->GetPath());

(

* p8 (

*

(mf.

())),

* p8e (p8 + vol_length / 8); p8 != p8e;

ostr <<

<<

current_offset (0);

unique_ptr<vector<Uint4> > pNrCounts (

vector<Uint4> (kNrMersTotal, 0));

vector<Uint4> & NrCounts (*pNrCounts);

cerr <<

<< subjdb->

() <<

;

* pcb (0);

* pcbe (pcb + bases / 4);

(npcb < npcb0) npcb += 8;

gcbase (4*(npcb - npcb0));

* pui8 (

*

(npcb));

* pui8_e (

*

(pcbe));

(

gccur (current_offset + gcbase); pui8 < pui8_e; ++pui8) {

(pui8 + 1 < pui8_e) {

ui8 |= (*(pui8 + 1) << 32);

current_offset += bases;

cerr <<

<< endl;

cerr <<

;

filename_temp_01;

unique_ptr<vector<Uint4> > pNrCounts2 (

vector<Uint4>);

vector<Uint4> & NrCounts2 (* pNrCounts2);

NrCounts2 = NrCounts;

total_mers (0);

(vector<Uint4>, ii, NrCounts) {

(*ii > 0) ++total_mers;

percentile ((

)(kNrMersTotal -

total_mers * (1 - kRepeatsPercentile)));

nth_element(NrCounts.begin(), NrCounts.begin() + percentile, NrCounts.end());

max_repeat_count (NrCounts[percentile]);

(filename_temp_01.empty()) {

NrCounts = NrCounts2;

(

(0);

< kNrMersTotal; ++

) {

len_bytes (kNrMersTotal / 8);

(src, src + kNrMersTotal / 64, dest);

cerr <<

;

(

(0);

< kNrMersTotal; ++

) {

(nrmers_plus.

(

)) {

irc (g_RC(

(

) << 4) & kUI4_Lo28);

cerr <<

<< endl;

num_seqs (blastdb.

());

seq_infos.reserve(num_seqs);

current_offset (0);

(seqlen <= 0 ||

(seqlen) >= 0xFFFFFFFF) {

ostr <<

<<

blastdb.

(oid).front()->GetSeqIdString(

);

bases (seqlen);

seq_infos.push_back(

(current_offset, bases, oid));

current_offset += bases;

ofstr_remap (full_remap_filename.c_str(), IOS_BASE::binary);

len_bytes (seq_infos.size() *

(

));

ofstr_remap.write((

*) &seq_infos.front(), len_bytes);

cerr <<

<< db <<

<< current_offset << endl;

seq_infos.reserve(num_seqs);

current_offset (0);

(seqlen <= 0 ||

(seqlen) >= 0xFFFFFFFF) {

ostr <<

<<

bases (seqlen);

current_offset += bases;

ofstr_remap (full_remap_filename.c_str(), IOS_BASE::binary);

len_bytes (seq_infos.size() *

(

));

ofstr_remap.write((

*) &seq_infos.front(), len_bytes);

cerr <<

<< current_offset << endl;

cerr <<

<< db <<

<< endl;

vector<Uint8> MersAndCoords (mcidx_max, 0);

current_offset (0);

ostr <<

<<

* pcb (0);

* pce (pcb + bases/4);

(npcb < npcb0) npcb += 8;

gcbase (4*(npcb - npcb0));

* pui8_start (

*

(npcb));

* pui8 (pui8_start);

(mcidx > 1000 && mcidx + max_new_elems >= mcidx_max) {

MersAndCoords.resize(mcidx);

MersAndCoords.assign(mcidx_max, 0);

(

gccur (current_offset + gcbase);

gccur + 16 < current_offset + bases && mcidx < mcidx_max;

(gccur + 32 >= current_offset + bases) {

w8 |= ((*(pui8 + 1)) << 32);

(

* p (pcb),

*pche ( (

*

(pui8)) + 5 );

c8 (*p & kUI8_LoByte);

ui8curbyte (c8);

fivebytes = (fivebytes >> 8) | (ui8curbyte << 32);

(

k(0); k < 4; ++k) {

mer (fivebytes & kUI8_LoWord);

(

.

(strand? (mer >> 4): (mer & kUI4_Lo28))) {

ui8 (mer);

coord (current_offset +

4*(p - pcb - 5) + k);

MersAndCoords[mcidx++] = (ui8 << 32) | coord;

fivebytes &= kUI8_LoFive;

ui8m ((fivebytes & kUI8_SeqDb) >> 16);

fivebytes &= ~kUI8_SeqDb;

fivebytes |= ui8curbyte << 32;

gccur (current_offset + gcbase);

(; gccur + 32 < current_offset + bases; ++pui8)

(

gccur_hi (gccur + 16); gccur < gccur_hi; ++gccur) {

loword = ui8 & kUI8_LoWord;

(loword & kUI4_Lo28)))

MersAndCoords[mcidx++] = (loword << 32) | gccur;

ui8hi2 ((ui8 >> 62) << 48);

ui8m ((ui8 & kUI8_SeqDb) >> 16);

ui8 |= (ui8m | ui8hi2);

(gccur + 32 < current_offset + bases) {

* pui4 (

*

(

));

ui8 |= (ui8_4 << 32);

(

gccur_hi (gccur + 16); gccur < gccur_hi; ++gccur) {

loword = ui8 & kUI8_LoWord;

(loword & kUI4_Lo28)))

MersAndCoords[mcidx++] = (loword << 32) | gccur;

ui8hi2 ((ui8 >> 62) << 48);

ui8m ((ui8 & kUI8_SeqDb) >> 16);

ui8 |= (ui8m | ui8hi2);

(gccur + 16 <= current_offset + bases) {

fivebytes = (gccur == current_offset + gcbase)? fivebytes:

* p (

*

(pui8_start) + 4

+ (gccur - current_offset - gcbase) / 4);

loword = fivebytes & kUI8_LoWord;

(loword & kUI4_Lo28)))

MersAndCoords[mcidx++] = (loword << 32) | gccur;

ui8 (*p++ & kUI8_LoByte);

fivebytes |= (ui8 << 32);

fivebytes &= kUI8_LoFive;

ui8m ((fivebytes & kUI8_SeqDb) >> 16);

fivebytes &= ~kUI8_SeqDb;

current_offset += bases;

(mcidx >= mcidx_max) {

ostr <<

<<

<<

;

MersAndCoords.resize(mcidx);

cerr <<

<< endl;

vector<Uint8> MersAndCoords (mcidx_max, 0);

current_offset (0);

ostr <<

<<

* pcb (0);

* pce (pcb + bases/4);

(npcb < npcb0) npcb += 8;

gcbase (4*(npcb - npcb0));

* pui8_start (

*

(npcb));

* pui8 (pui8_start);

(mcidx > 1000 && mcidx + max_new_elems >= mcidx_max) {

MersAndCoords.resize(mcidx);

MersAndCoords.assign(mcidx_max, 0);

(

gccur (current_offset + gcbase);

gccur + 16 < current_offset + bases && mcidx < mcidx_max;

(gccur + 32 >= current_offset + bases) {

w8 |= ((*(pui8 + 1)) << 32);

fivebytes (0);

(

* p (pcb),

*pche ( (

*

(pui8)) + 5 );

c8 (*p & kUI8_LoByte);

ui8curbyte (c8);

fivebytes = (fivebytes >> 8) | (ui8curbyte << 32);

(

k(0); k < 4; ++k) {

mer (fivebytes & kUI8_LoWord);

(

.

(strand? (mer >> 4): (mer & kUI4_Lo28))) {

ui8 (mer);

coord (current_offset +

4*(p - pcb - 5) + k);

MersAndCoords[mcidx++] = (ui8 << 32) | coord;

fivebytes &= kUI8_LoFive;

ui8m ((fivebytes & kUI8_SeqDb) >> 16);

fivebytes &= ~kUI8_SeqDb;

fivebytes |= ui8curbyte << 32;

gccur (current_offset + gcbase);

(; gccur + 32 < current_offset + bases; ++pui8)

(

gccur_hi (gccur + 16); gccur < gccur_hi; ++gccur) {

loword = ui8 & kUI8_LoWord;

(loword & kUI4_Lo28)))

MersAndCoords[mcidx++] = (loword << 32) | gccur;

ui8hi2 ((ui8 >> 62) << 48);

ui8m ((ui8 & kUI8_SeqDb) >> 16);

ui8 |= (ui8m | ui8hi2);

(gccur + 32 < current_offset + bases) {

* pui4 (

*

(

));

ui8 |= (ui8_4 << 32);

(

gccur_hi (gccur + 16); gccur < gccur_hi; ++gccur) {

loword = ui8 & kUI8_LoWord;

(loword & kUI4_Lo28)))

MersAndCoords[mcidx++] = (loword << 32) | gccur;

ui8hi2 ((ui8 >> 62) << 48);

ui8m ((ui8 & kUI8_SeqDb) >> 16);

ui8 |= (ui8m | ui8hi2);

(gccur + 16 <= current_offset + bases) {

fivebytes = (gccur == current_offset + gcbase)? fivebytes:

(ui8 & kUI8_LoWord);

* p (

*

(pui8_start) + 4

+ (gccur - current_offset - gcbase) / 4);

loword = fivebytes & kUI8_LoWord;

(loword & kUI4_Lo28)))

MersAndCoords[mcidx++] = (loword << 32) | gccur;

ui8 (*p++ & kUI8_LoByte);

fivebytes |= (ui8 << 32);

fivebytes &= kUI8_LoFive;

ui8m ((fivebytes & kUI8_SeqDb) >> 16);

fivebytes &= ~kUI8_SeqDb;

current_offset += bases;

(mcidx >= mcidx_max) {

ostr <<

<<

<<

;

MersAndCoords.resize(mcidx);

vector<Uint8>& MersAndCoords)

t0 (time(0));

ofstr_offs (filename_offs.c_str(), IOS_BASE::binary);

bytes_offs (0);

ofstr_positions (filename_positions.c_str(), IOS_BASE::binary);

bytes_positions (0);

cerr <<

<<

<<

;

(MersAndCoords.begin(), MersAndCoords.end());

(vector<Uint8>, ii, MersAndCoords) {

mer ((*ii & kUI8_HiWord) >> 32);

(mer != curmer) {

ofstr_offs.write((

*) &mer,

mer);

ofstr_offs.write((

*) &curofs,

curofs);

bytes_offs +=

(mer) +

(curofs);

pos (*ii & kUI8_LoWord);

ofstr_positions.write((

*) &pos,

pos);

bytes_positions +=

(pos);

mer (0);

ofstr_offs.write((

*)&mer,

mer);

ofstr_offs.write((

*)&curofs,

curofs);

bytes_offs +=

(mer) +

(curofs);

ofstr_positions.close();

cerr <<

<< endl;

time(0) - t0;

<< ofs1 << " different from " << ofs << endl; \

const size_t len1 (mm.GetSize()); \

cerr << "Real length " << len1 << " different from " << len << endl; \

cerr <<

<< (strand?

:

) <<

;

sfx (

(strand?

:

) +

);

mask_ofs_q (

+ sfx + kFileExt_Offsets);

mask_ofs_s (

+ sfx + kFileExt_Offsets);

elem_hits_total (0);

filename_ofs_s ((*ii_s)->GetPath());

filename_pos_s (

(filename_ofs_s, kFileExt_Positions));

file_subj (filename_ofs_s);

dim_ofs_s (file_subj.

() / 8);

filename_ofs_q ((*ii_q)->GetPath());

filename_pos_q (

(filename_ofs_q,

kFileExt_Positions));

hit_index_dim (0), elem_hits_this_pair (0);

filename_hit_index;

* ofs_s (

*

(mf_ofs_s.

()));

file_query ((*ii_q)->GetPath());

dim_ofs_q (file_query.

() / 8);

* ofs_q (

*

(mf_ofs_q.

()));

hit_index.reserve(

(dim_ofs_q, dim_ofs_s));

((*ofs_q & kUI8_LoWord) && (*ofs_s & kUI8_LoWord)) {

( (*ofs_q & kUI8_LoWord)

&& ((*ofs_q & kUI8_LoWord) < (*ofs_s & kUI8_LoWord)))

((*ofs_q & kUI8_LoWord) == 0)

;

( (*ofs_s & kUI8_LoWord)

&& ((*ofs_s & kUI8_LoWord) < (*ofs_q & kUI8_LoWord)))

((*ofs_s & kUI8_LoWord) == 0)

;

((*ofs_s & kUI8_LoWord) == (*ofs_q & kUI8_LoWord)) {

hit_index_dim = (hit_index.size());

elem_hits_total += elem_hits_this_pair;

file_pos_s (filename_pos_s);

dim_pos_s (file_pos_s.

() / 4);

map_offset_s (0);

map_length_s (

(kMapGran, 4*dim_pos_s - map_offset_s));

* pos_s (

*

(

mf_pos_s.

(map_offset_s, map_length_s)));

file_pos_q (filename_pos_q);

dim_pos_q (file_pos_q.

() / 4);

map_offset_q (0);

map_length_q (

(kMapGran, 4*dim_pos_q - map_offset_q));

* pos_q (

*

(

mf_pos_q.

(map_offset_q, map_length_q)));

vector<Uint8> hits (elem_hits_this_pair);

ifstr (filename_hit_index.c_str(), IOS_BASE::binary);

(

(0);

< hit_index_dim; ++

) {

ifstr.read((

*) &hie,

(hie));

(idx_s_max > dim_pos_s || idx_q_max > dim_pos_q) {

(4*idx_s_max >= map_offset_s + map_length_s) {

map_length_s =

(kMapGran, 4*dim_pos_s - map_offset_s);

pos_s = (

*

(mf_pos_s.

(map_offset_s, map_length_s)));

(4*idx_q_max >= map_offset_q + map_length_q) {

map_length_q =

(kMapGran, 4*dim_pos_q - map_offset_q);

pos_q = (

*

(mf_pos_q.

(map_offset_q, map_length_q)));

(

idx_s (hie.

); idx_s < idx_s_max; ++idx_s) {

hiword = pos_s[idx_s - map_offset_s/4];

(

idx_q (hie.

); idx_q < idx_q_max; ++idx_q) {

loword = pos_q[idx_q - map_offset_q/4];

hits[hidx++] = (hiword | loword);

(hidx != elem_hits_this_pair) {

ostr <<

<< hidx

<<

<< elem_hits_this_pair;

cerr <<

<< endl;

(lhs & kUI8_LoWord) < (rhs & kUI8_LoWord);

lhs_q (

(lhs & kUI8_LoWord) / 2);

lhs_s (

(lhs >> 32) / 2);

rhs_q (

(rhs & kUI8_LoWord) / 2);

rhs_s (

(rhs >> 32) / 2);

lhs_q1 (lhs_q + lhs_s);

lhs_s1 (lhs_s - lhs_q);

rhs_q1 (rhs_q + rhs_s);

rhs_s1 (rhs_s - rhs_q);

(lhs_s1 == rhs_s1) {

lhs_q1 < rhs_q1;

lhs_s1 < rhs_s1;

(lbn +

+ *ii);

fdl.

((*jj)->GetPath());

(phits->size() == 0) {

(phits->begin(), phits->end());

TSeqInfos::const_iterator ii_genomic (ii_genomic_b);

idx_compacted (0);

(

idx (0), idx_hi (phits->size()); idx < idx_hi; ) {

gc_s (((*phits)[idx]) >> 32);

ii_genomic = lower_bound(ii_genomic + 1, ii_genomic_e,

(gc_s, 0, 0));

(ii_genomic == ii_genomic_e || ii_genomic->m_Start > gc_s) {

(gc_s < ii_genomic->m_Start ||

ii_genomic->m_Start + ii_genomic->m_Length <= gc_s)

ostr <<

<< gc_s <<

<< ii_genomic->m_Start <<

<< (ii_genomic->m_Start + ii_genomic->m_Length) <<

gc_s_max (ii_genomic->m_Start + ii_genomic->m_Length);

(idx < idx_hi && (((*phits)[idx]) >> 32) < gc_s_max) {

(phits->begin() + idx0, phits->begin() + idx,

);

TSeqInfos::const_iterator ii_cdna (ii_cdna_b);

gc_q_min (ii_cdna->m_Start);

gc_q_max (ii_cdna->m_Start + ii_cdna->m_Length);

jdx (idx0), jdx0 (jdx);

(; jdx < idx; ++jdx) {

gc_q (((*phits)[jdx]) & kUI8_LoWord);

(gc_q < gc_q_min || gc_q >= gc_q_max) {

(

* (jdx - jdx0) >= min_matches / 2) {

jdx0, jdx, &idx_compacted);

ii_cdna = lower_bound(ii_cdna + 1, ii_cdna_e,

(gc_q, 0, 0));

(ii_cdna == ii_cdna_e || ii_cdna->m_Start > gc_q) {

(gc_q < ii_cdna->m_Start ||

ii_cdna->m_Start + ii_cdna->m_Length <= gc_q)

ostr <<

<< gc_q <<

<< ii_cdna->m_Start <<

<< (ii_cdna->m_Start + ii_cdna->m_Length) <<

<< (

[ii_cdna->m_Oid]->GetSeqIdString(

));

gc_q_min = ii_cdna->m_Start;

gc_q_max = ii_cdna->m_Start + ii_cdna->m_Length;

(

* (jdx - jdx0) >= min_matches / 2) {

jdx0, jdx, &idx_compacted);

& right_limit0,

Wm (1), Wms (-2);

score (

(hitref->GetLength()) * Wm

+

(hitref->GetMismatches()) * (Wms - Wm));

score_max (score);

overrun (6);

left_limit (left_limit0 >= overrun? left_limit0 - overrun: 0);

right_limit (right_limit0 >= kDiagMax - overrun?

kDiagMax: right_limit0 + overrun);

q0 (hitref->GetQueryStart()), s0 (hitref->GetSubjStart());

mm (0), mm0 (0);

no_overrun_yet (

);

(

q (q0 - 1), s (s0 - 1);

(q + s > left_limit && score +

>= score_max

(q + s == left_limit0) {

no_overrun_yet =

;

(score > score_max) {

(no_overrun_yet) {

(q0 + s0 <= left_limit0) {++q0; ++s0;}

extended_left (

);

(q0 < hitref->GetQueryStart()) {

hitref->SetQueryStart(q0);

hitref->SetSubjStart(s0);

extended_left =

;

q0 = (hitref->GetQueryStop());

s0 = (hitref->GetSubjStop());

no_overrun_yet =

;

(

q (q0 + 1), s (s0 + 1);

(q + s < right_limit && score + m_XDropOff >= score_max

(q + s == right_limit0) {

no_overrun_yet =

;

(score > score_max) {

(no_overrun_yet) {

(q0 + s0 >= right_limit0) {--q0; --s0; }

extended_right (

);

(q0 > hitref->GetQueryStop()) {

hitref->SetQueryStop(q0);

hitref->SetSubjStop(s0);

extended_right =

;

(extended_left || extended_right) {

hitref->SetMismatches(mm0);

(hitref->GetQueryStop() - hitref->GetQueryStart() + 1);

hitref->SetLength(

);

hitref->SetIdentity((

- mm0) /

(

));

hitref->SetScore(2 *

);

TSeqInfos::const_iterator ii_cdna,

TSeqInfos::const_iterator ii_genomic,

* pidx_compacted)

(idx_start >= idx_stop) {

(pvol->begin() + idx_start, pvol->begin() + idx_stop,

);

idx_compacted_start (*pidx_compacted);

lens.reserve(pvol->size() / 2);

qs0 ((*pvol)[idx_start]);

q0 (qs0 & kUI8_LoWord);

s0 (qs0 >> 32);

(*pvol)[(*pidx_compacted)++] = qs0;

(

idx (idx_start + 1); idx < idx_stop; ++idx) {

qs ((*pvol)[idx]);

q (qs & kUI8_LoWord);

s (qs >> 32);

((q0 >= s0 && q0 - s0 == q - s && q <= q0 + 16) ||

(q0 < s0 && s0 - q0 == s - q && q <= q0 + 16) )

lens.back() += q - q0;

(*pvol)[(*pidx_compacted)++] = qs;

(

idx (idx_compacted_start); idx < *pidx_compacted; ++idx) {

qs ((*pvol)[idx]);

q (qs & kUI8_LoWord);

s (qs >> 32);

hitref->SetQueryStart(q);

hitref->SetSubjStart(s);

(lens[idx - idx_compacted_start]);

hitref->SetQueryStop(q +

- 1);

hitref->SetSubjStop(s +

- 1);

hitref->SetMismatches(0);

hitref->SetEValue(0);

hitref->SetIdentity(1.0);

hitref->SetLength(

);

hitref->SetScore(2*

);

hitrefs[idx - idx_compacted_start] = hitref;

left_limit (0);

right_limit (kDiagMax);

s_prime_cur (0);

kn (hitrefs.size());

(

k(0); k < kn; ++k) {

(

(box[2]) -

(box[0]) != s_prime_cur) {

left_limit = box[0];

s_prime_cur =

(box[2]) -

(box[0]);

right_limit = kDiagMax;

(

(boX[2]) -

(boX[0]) == s_prime_cur) {

right_limit = boX[0] + boX[2];

left_limit =

(left_limit, right_limit, hitrefs[k]);

rlimit (0), spc (0);

(

k (0); k < kn; ++k) {

cur_diag_stop (hitrefs[k]->GetQueryStop()

+ hitrefs[k]->GetSubjStop());

s_prime (-

(hitrefs[k]->GetQueryStart())

+

(hitrefs[k]->GetSubjStart()));

(k == 0 || spc != s_prime) {

hitrefs[++d] = hitrefs[k];

rlimit = cur_diag_stop;

cur_diag_start (hitrefs[k]->GetQueryStart()

+ hitrefs[k]->GetSubjStart());

(rlimit + 2 == cur_diag_start) {

rlimit = cur_diag_stop;

hrd->SetQueryStop(hitrefs[k]->GetQueryStop());

hrd->SetSubjStop(hitrefs[k]->GetSubjStop());

hrd->SetMismatches(hrd->GetMismatches()

+ hitrefs[k]->GetMismatches());

- hrd->GetQueryStart() + 1);

hrd->SetLength(

);

hrd->SetIdentity(

(

- hrd->GetMismatches()) /

);

hrd->SetScore(2 *

);

(rlimit + 1 < cur_diag_start) {

hitrefs[++d] = hitrefs[k];

rlimit = cur_diag_stop;

);

hitrefs.resize(

(

(d + 1), kn));

((*ii)->GetQueryStop() >= qmax) {

(*ii)->Modify(1, qmax - 1);

& h (**ii);

ca.

(hitrefs.begin(), hitrefs.end());

& h (**ii);

pair_results->Set().begin(),

pair_results->Set().end());

ifstr_genomic (filename_genomic.c_str(), IOS_BASE::binary);

elems_genomic * sizeof (

));

ifstr_genomic.close();

ifstr_cdna (filename_cdna.c_str(), IOS_BASE::binary);

rv = (rv * 3 + (*ii)) % 3571;

- 5000 + rv;

vol_exts.push_back(kFileExt_Offsets);

vol_exts.push_back(kFileExt_Positions);

vol_exts.push_back(kFileExt_Offsets);

vol_exts.push_back(kFileExt_Positions);

vol_exts.push_back(kFileExt_Masked);

vol_exts.push_back(kFileExt_Remap);

ncbi::TMaskedQueryRegions mask

const TCoord * GetBox(void) const

void SetSubjId(const TId &id)

void SetBox(const TCoord box[4])

void SetQueryId(const TId &id)

static CSafeStatic< vector< CSeq_id_Handle > > s_ids

TCoord GetLength(void) const

void Run(typename THitRefs::iterator start, typename THitRefs::iterator finish, CScope *scope=NULL, const vector< pair< TCoord, TCoord > > *gaps=NULL)

Execute: identify compartments.

void SetMaxIntron(TCoord mi)

Assign the maximum intron length, in base pairs.

bool GetFirst(THitRefs &compartment)

Initialize iteration over the results.

CRef< objects::CSeq_align_set > AsSeqAlignSet(void) const

Retrieve all valid compartments in a seq-align-set.

bool GetNext(THitRefs &compartment)

Proceed with iteration over the results.

static TCoord s_GetDefaultMaxIntron(void)

Retrieve the default maximum length of an intron.

void reset_at(const Uint8 idx)

void set_at(const Uint8 idx)

bool get_at(const Uint8 idx) const

void Init(Uint8 dim_bits, bool init_value)

const Uint8 * GetBuffer(void) const

const char * m_CurSeq_cDNA

double m_MinCompartmentIdty

vector< SSeqInfo > TSeqInfos

void x_LoadRemapData(ISequenceSource *m_qsrc, const string &sdb)

void x_InitParticipationVector(bool strand)

void x_CleanVolumes(const string &lbn, const TStrings &vol_extensions)

void x_Search(bool strand)

vector< THitRef > THitRefs

void x_CreateRemapData(const string &db, EIndexMode mode)

vector< string > TStrings

TSeqInfos m_SeqInfos_Genomic

TSeqInfos::const_iterator m_ii_cdna

size_t x_WriteIndexFile(size_t volume, EIndexMode mode, bool strand, vector< Uint8 > &MersAndCoords)

static bool s_IsLowComplexity(size_t key)

double m_MinSingletonIdty

Int8 x_ExtendHit(const Int8 &left_limit, const Int8 &right_limit, THitRef hitref)

TSeqInfos m_SeqInfos_cdna

bool x_IsMatch(Uint8 q, Uint8 s) const

vector< SHitIndexEntry > THitIndex

const char * m_CurSeq_Genomic

void x_CreateIndex(const string &db, EIndexMode index_more, bool strand)

void x_CompartPair(vector< Uint8 > *pvol, TSeqInfos::const_iterator ii_cdna, TSeqInfos::const_iterator ii_genomic, size_t idx_start, size_t idx_stop, size_t *pidx_compacted)

void x_InitFilteringVector(const string &sdb, bool strand)

void x_CompartVolume(vector< Uint8 > *phits)

TSeqInfos::const_iterator m_ii_genomic

CNcbiOstrstreamToString class helps convert CNcbiOstrstream to a string Sample usage:

CReverseAndComplement(void)

Uint8 GetTotalLength() const

Returns the sum of the lengths of all available sequences.

list< CRef< CSeq_id > > GetSeqIDs(int oid) const

Gets a list of sequence identifiers.

int GetSeqLength(int oid) const

Returns the sequence length in base pairs or residues.

void RetSequence(const char **buffer) const

Returns any resources associated with the sequence.

int GetNumSeqs() const

Returns the number of sequences available.

int GetSequence(int oid, const char **buffer) const

Get a pointer to raw sequence data.

bool CheckOrFindOID(int &next_oid) const

Find an included OID, incrementing next_oid if necessary.

virtual CConstRef< CSeq_id > GetSeqID(int idx)

virtual Uint8 GetTotalLength(void)

virtual int GetSeqLength(int idx)

virtual bool GetNext(void)

virtual int GetNumSeqs(void)

virtual void ResetIndex(void)

virtual int GetSeq(const char **buffer)

virtual int GetCurrentIndex()

virtual void RetSequence(const char **)

void g_RestoreFromTemp(const string &filename, VectorT *pvd)

string GetLocalBaseName(const string &extended_name, const string &sfx)

#define QCOMP_COUNT_NrMERS

bool PLoWord(const Uint8 &lhs, const Uint8 &rhs)

void CheckWrittenFile(const string &filename, const Uint8 &len_bytes)

char DecodeSeqDbChar(Uint1 c)

CRandom::TValue GenerateSeed(const string &str)

string ReplaceExt(const string &extended_name, const string &new_ext)

string g_SaveToTemp(const VectorT &v, const string &path)

#define QCOMP_CREATE_GENOMIC_IDX(w8, gccur)

T ReverseAndComplement(T v)

#define QCOMP_PREPARE_SHIFTED_GENOMIC_IDX

bool PDiag(const Uint8 &lhs, const Uint8 &rhs)

static const char * str(char *buf, int n)

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

TEntries GetEntries(const string &mask=kEmptyStr, TGetEntriesFlags flags=0) const

Get directory entries based on the specified "mask".

static string GetTmpNameEx(const string &dir=kEmptyStr, const string &prefix=kEmptyStr, ETmpFileCreationMode mode=eTmpFileGetName)

Get temporary file name.

void * Map(TOffsetType offset=0, size_t length=0)

Map file.

Int8 GetLength(void) const

Get size of file.

virtual bool Remove(TRemoveFlags flags=eRecursive) const

Remove a directory entry.

bool Unmap(void)

Unmap file if mapped.

static char GetPathSeparator(void)

Get path separator symbol specific for the current platform.

void Add(const string &path)

Add a path for later deletion.

static void SplitPath(const string &path, string *dir=0, string *base=0, string *ext=0)

Split a path string into its basic components.

@ eCreate

Create new file or rewrite existent with zeros.

@ eMMS_Shared

Changes are shared.

@ eMMP_Write

Data can be written.

string GetSeqIdString(bool with_version=false) const

Return seqid string with optional version for text seqid type.

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

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

void Reset(void)

Reset reference object.

uint8_t Uint1

1-byte (8-bit) unsigned integer

int32_t Int4

4-byte (32-bit) signed integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

int64_t Int8

8-byte (64-bit) signed integer

uint64_t Uint8

8-byte (64-bit) unsigned integer

Uint4 TValue

Type of the generated integer value and/or the seed value.

TValue GetRand(void)

Get the next random number in the interval [0..GetMax()] (inclusive)

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

IO_PREFIX::ofstream CNcbiOfstream

Portable alias for ofstream.

IO_PREFIX::ifstream CNcbiIfstream

Portable alias for ifstream.

static enable_if< is_arithmetic< TNumeric >::value||is_convertible< TNumeric, Int8 >::value, string >::type NumericToString(TNumeric value, TNumToStringFlags flags=0, int base=10)

Convert numeric value to string.

constexpr auto sort(_Init &&init)

double value_type

The numeric datatype used by the parser.

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

void SleepSec(unsigned long sec, EInterruptOnSignal onsignal=eRestartOnSignal)

Sleep.

Defines classes: CDirEntry, CFile, CDir, CSymLink, CMemoryFile, CFileUtil, CFileLock,...

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

Defines BLAST database access classes.

const value_slice::CValueConvert< value_slice::SRunTimeCP, FROM > Convert(const FROM &value)

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