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

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

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

kNonCoveredEndThreshold (55);

kPower (2.5);

kMinTermExonSize (28);

kMinTermExonIdty (0.9);

kFlankExonProx (20);

kMaxCutToSplice (6);

kEstMatchScore (1000);

kEstMismatchScore (-1011);

kEstGapOpeningScore(-1460);

kEstGapExtensionScore(-464);

kEstGtAgSpliceScore(-4988);

kEstGcAgSpliceScore(-5999);

kEstAtAcSpliceScore(-7010);

kEstNonConsensusSpliceScore(-13060);

m_CanResetHistory (

),

m_ScoringType(s_GetDefaultScoringType()),

m_MatchScore(s_GetDefaultMatchScore()),

m_MismatchScore(s_GetDefaultMismatchScore()),

m_GapOpeningScore(s_GetDefaultGapOpeningScore()),

m_GapExtensionScore(s_GetDefaultGapExtensionScore()),

m_GtAgSpliceScore(s_GetDefaultGtAgSpliceScore()),

m_GcAgSpliceScore(s_GetDefaultGcAgSpliceScore()),

m_AtAcSpliceScore(s_GetDefaultAtAcSpliceScore()),

m_NonConsensusSpliceScore(s_GetDefaultNonConsensusSpliceScore()),

m_MinExonIdty(s_GetDefaultMinExonIdty()),

m_MinPolyaExtIdty(s_GetDefaultPolyaExtIdty()),

m_MinPolyaLen(s_GetDefaultMinPolyaLen()),

m_MinHoleLen(s_GetDefaultMinHoleLen()),

m_TrimToCodons(s_GetDefaultTrimToCodons()),

m_CompartmentPenalty(s_GetDefaultCompartmentPenalty()),

m_MinCompartmentIdty(s_GetDefaultMinCompartmentIdty()),

m_MinSingletonIdty(s_GetDefaultMinCompartmentIdty()),

m_max_genomic_ext (s_GetDefaultMaxGenomicExtent()),

m_MaxPartExonIdentDrop (s_GetDefaultMaxPartExonIdentDrop()),

m_MaxCompsPerQuery (0),

m_MinPatternHitLength (13)

aligner->SetScoreMatrix(

);

(low_query_quality) {

aligner->

(kEstMatchScore);

aligner->

(kEstMismatchScore);

aligner->

(kEstGapOpeningScore);

aligner->

(kEstGapExtensionScore);

aligner->

(0, kEstGtAgSpliceScore);

aligner->

(1, kEstGcAgSpliceScore);

aligner->

(2, kEstAtAcSpliceScore);

aligner->

(3, kEstNonConsensusSpliceScore);

(!(0 <= idty && idty <= 1)) {

(!(0 <= idty && idty <= 1)) {

(!(0 <= idty && idty <= 1)) {

(!(0 <= idty && idty <= 1)) {

(penalty < 0 || penalty > 1) {

( pos+1 == 0 || pos >=

.size() )

;

retain,

is_genomic,

genomic_strand)

(

)

(start > finish) {

ostr <<

<< start <<

<< finish;

tmp_loc(*tmp_id, start, finish, strand);

seq->resize(1 + finish - start);

(s.begin(), s.end(), seq->begin());

->RemoveFromHistory(bh);

(

loop = start; loop <= finish; loop++) {

hr->SetQueryStart(q0);

hr->SetSubjStart(s0);

hr->SetQueryStop(q - 1);

hr->SetSubjStop(s - 1);

hr->SetLength(q - q0);

hr->SetMismatches(0);

hr->SetScore(2*(q - q0));

* Seq1 (&

.front());

* Seq2 (&

.front());

idty (h->GetIdentity());

diag (h->GetGaps() == 0 && h->GetQuerySpan() == h->GetSubjSpan());

(idty == 1 || idty < .95 || h->

() < 100 || !diag) {

q0 (-1), s0 (-1), q1 (h->GetQueryMax());

q (h->GetQueryMin()), s (h->GetSubjMin());

(Seq1[q++] != Seq2[s++]) {

hr->SetQueryId(h->GetQueryId());

hr->SetSubjId(h->GetSubjId());

hr->SetQueryId(h->GetQueryId());

hr->SetSubjId(h->GetSubjId());

THitComparator sorter (THitComparator::eQueryMin);

stable_sort(phitrefs->begin(), phitrefs->end(), sorter);

non_intersect = ( prevSmax < h->GetSubjMin() ) || ( prevSmin > h->GetSubjMax() );

(!non_intersect) {

consistent (h->GetSubjStrand()?

+

(

));

= h->GetSubjStop();

prevSmin = h->GetSubjMin();

prevSmax = h->GetSubjMax();

phitrefs->erase(

(phitrefs->begin(), phitrefs->end(),

vector<size_t> pattern0;

vector<pair<bool,double> > imperfect;

max_idty (0.0);

(

(0),

(phitrefs->size());

<

; ++

) {

& h ((*phitrefs)[

]);

valid (

);

pattern0.push_back(h->GetQueryMin());

pattern0.push_back(h->GetQueryMax());

pattern0.push_back(h->GetSubjMin());

pattern0.push_back(h->GetSubjMax());

idty (h->GetIdentity());

imprf (idty < 1.00

|| h->GetQuerySpan() != h->GetSubjSpan()

|| h->GetMismatches() > 0

|| h->GetGaps() > 0);

imperfect.push_back(pair<bool,double>(imprf, idty));

(idty > max_idty) {

(max_idty < .85 && pattern0.size() >= 4) {

dim (pattern0.size());

* Seq1 (&

.front());

* Seq2 (&

.front());

SeqLen2 (

.size());

some_error (

), bad_input (

);

(

(0);

< dim;

+= 4) {

(pattern0[

] > pattern0[

+1] || pattern0[

+2] > pattern0[

+3]) {

ostr_err <<

;

some_error = bad_input =

;

(pattern0[

] <= pattern0[

-3] || pattern0[

+2] <= pattern0[

-1]) {

<<

(

);

br1 (pattern0[

+1] >= SeqLen1);

br2 (pattern0[

+3] >= SeqLen2);

ostr_err <<

<< phitrefs->front()->GetQueryId()->GetSeqIdString(

)

<< phitrefs->front()->GetSubjId()->GetSeqIdString(

)

ostr_err <<

<< pattern0[

+1]

<<

<< SeqLen1 << endl;

ostr_err <<

<< pattern0[

+3]

<<

<< SeqLen2 << endl;

ostr_err <<

;

some_error = bad_input =

;

ostr_err <<

<< phitrefs->front()->GetQueryId()->AsFastaString()

<< phitrefs->front()->GetSubjId()->AsFastaString() <<

(err.size() > 0) {

map_elem.

[0] = map_elem.

[2] = 0;

(

= 0;

< dim;

+= 4) {

L1, R1, L2, R2;

max_seg_size (0);

imprf (imperfect[

/4].

);

len1 (pattern0[

+1] - pattern0[

] + 1);

len2 (pattern0[

+3] - pattern0[

+2] + 1);

maxlen (

(len1, len2));

lendif (len1 < len2? len2 - len1: len1 - len2);

band (

((1 - imperfect[

/4].second) * maxlen) + 2);

(band < lendif) band += lendif;

Seq2 + pattern0[

+2], len2,

R1 = pattern0[

+1] - pattern0[

] - 1;

R2 = pattern0[

+3] - pattern0[

+2] - 1;

max_seg_size = R1 - L1 + 1;

cut ((1 + R1 - L1) / 5);

(cut > 20) cut = 20;

l1 (L1 + cut), l2 (L2 + cut);

(R1 - cut),

(R2 - cut);

(l1 <

&& l2 <

) {

q0 (pattern0[

] + L1);

s0 (pattern0[

+2] + L2);

q1 (pattern0[

] + R1);

s1 (pattern0[

+2] + R2);

hitlen_q (pattern0[

+ 1] - pattern0[

] + 1);

sh (

(hitlen_q / 4));

(sh > L1? sh - L1: 0);

h2s_right (hitlen_q - R1 - 1);

= sh > h2s_right? sh - h2s_right: 0;

(q0 > q1 || s0 > s1) {

q0 = pattern0[

] + L1;

s0 = pattern0[

+2] + L2;

q1 = pattern0[

] + R1;

s1 = pattern0[

+2] + R2;

pattern_dim =

.size();

map_elem.

[1] = pattern0[

+1];

map_elem.

[3] = pattern0[

+3];

map_elem.

[1] = SeqLen1 - 1;

map_elem.

[3] = SeqLen2 - 1;

strid (id->AsFastaString());

(seq_data == 0) {

vector<CRef<CSeq_loc> > orfs;

vector<string> start_codon;

start_codon.push_back(

);

max_len_plus (0), max_len_minus (0);

max_from_plus (0), max_from_minus (0);

max_to_plus (0), max_to_minus (0);

orf_strand ((*orf)->GetInt().GetStrand());

(

> max_len_minus) {

max_len_minus =

;

max_from_minus = (*orf)->GetInt().GetTo();

max_to_minus = (*orf)->GetInt().GetFrom();

(

> max_len_plus) {

max_len_plus =

;

max_from_plus = (*orf)->GetInt().GetFrom();

max_to_plus = (*orf)->GetInt().GetTo();

(max_len_plus > 0) {

rv.first =

(max_from_plus, max_to_plus);

(max_len_minus > 0) {

rv.second =

(max_from_minus, max_to_minus);

(h.

() && h->GetQueryStrand() ==

) {

(hitrefs.size() == 0) {

id_query (hitrefs.front()->GetQueryId());

(mrna_size == kMaxCoord) {

(

) + id_query->AsFastaString());

min_singleton_idty_final,

comps.

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

());

comps.

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

pair<size_t,size_t> dim (comps.

());

(dim.second > 0) {

same_strand (

);

(

(0);

< dim.first; ++

, box += 4) {

(

+ 1 == dim.first) {

same_strand =

;

same_strand = strand_this == strand_next;

smax = same_strand? (box + 4)[2]:

;

(smax < box[3]) {

);

comps.

(

, comp_hits);

(smax < box[3]) smax = box[3];

(smin > box[2]) smin = box[2];

smin = same_strand? box[3]: 0;

id_query (phitrefs->front()->GetQueryId());

kMinPercAInPolya (0.80);

(

= polya_start;

<dim; ++

) {

(seq[

] ==

) ++

;

(

>= (dim - polya_start)*kMinPercAInPolya)

;

kMaxNonA (3), kMinAstreak (5);

(dim - 1), i0 (dim);

(

count_non_a (0), astreak (0);

>= 0 && count_non_a < kMaxNonA; --

) {

(seq[

] !=

) {

(++astreak >= kMinAstreak) {

(dim - i0);

(

>= kMinAstreak) {

(0 < cds_stop && cds_stop < dim && rv <= cds_stop) {

(range_left > range_right) {

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

(

(0),

(phitrefs->size());

<

; ++

) {

new_strand (!(h->GetSubjStrand()));

h->SetQueryStart(a1);

h->SetQueryStop(a0);

h->SetSubjStrand(new_strand);

THitRefs::iterator ii (phitrefs->begin()), jj (phitrefs->end() - 1);

b0 (

), b1 (

);

(b0 && b1 && ii < jj) {

(ii->IsNull() && ii < jj) ++ii;

(jj->IsNull() && ii < jj) --jj;

hit_idty ((*ii)->GetIdentity());

min_termhitlen (

hit_idty < .9999? min_termhitlen2: min_termhitlen1);

((*ii)->GetQuerySpan() < min_termhitlen) {

hit_idty ((*jj)->GetIdentity());

min_termhitlen (

hit_idty < .9999? min_termhitlen2: min_termhitlen1);

((*jj)->GetQuerySpan() < min_termhitlen) {

phitrefs->erase(

(phitrefs->begin(), phitrefs->end(),

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

qmin (span[0]), qmax (span[1]), smin (span[2]), smax (span[3]);

ctg_strand (phitrefs->front()->GetSubjStrand());

fixed_left (kMaxCoord / 2), fixed_right(fixed_left);

kTermLenCutOff_m2 (10);

fix_left (qmin <= kTermLenCutOff_m2);

fix_right (rspace <= kTermLenCutOff_m2);

(fix_left || fix_right) {

(phitrefs->size() > 1) {

prev_start (phitrefs->front()->GetSubjStart());

cur_start - prev_start:

prev_start - cur_start);

(intron > max_intron) {

max_intron = intron;

prev_start = cur_start;

factor (2.5);

(fix_left) { fixed_left =

(max_intron * factor); }

(fix_right) { fixed_right =

(max_intron * factor); }

(fix_left) { fixed_left = single_hit_extent; }

(fix_right) { fixed_right = single_hit_extent; }

extent_left (

(extent_left_m1, extent_left_m2));

(extent_right < poly_length) extent_right = poly_length;

smin =

(0,

(smin - extent_left));

smax += extent_right;

smin =

(0,

(smin - extent_right));

smax += extent_left;

(smin < range_left) {

(smax > range_right) {

(phitrefs->size() > 1) {

id_query (phitrefs->front()->GetSubjId());

tmp_id->

(*id_query);

(hitmin > smin) {

tmplen = hitmin - smin;

(;smit; ++smit) {

( smin + pos <= hitmin );

(smax > hitmax) {

tmplen = smax - hitmax;

(;smit; ++smit) {

( hitmax + pos < smax );

smax = hitmax + pos;

smin, smax,

,

, ctg_strand);

(smax >= ctg_end) {

smax = ctg_end > 0? ctg_end - 1: 0;

(ctg_strand ==

) {

(!(smin <= hsmin && hsmax <= smax)) {

ostr <<

<< *h

<<

<< smin+1 <<

<< smax+1 <<

<<

;

(ctg_strand ==

) {

h->SetSubjStart(a2);

(*ii)->Shift(-(

)qmin, -(

)smin);

last_exon = -1;

(last_exon == -1) {

* p0 = &

.front() + s.

[1] + 1;

* p = p0;

* q = q0;

* pe = &

.front() + mrna_size;

sh = 0,

=0;

(; p < pe && q < qe; ++p, ++q, ++

) {

(

(*p) !=

&& *p == *q) {

(;p>=p0;--p,--q,++

) {

(

(*p) !=

&& *p == *q) {

( match_num <

*kMinExonFlankIdty) {

(

= 0,p = p0, q = q0;

< sh; ++p, ++q, ++

) {

(

(*p) !=

&& *p == *q) {

ann_dim = s.

.size();

(ann_dim > 2 && s.

[ann_dim - 3] ==

) {

s.

[ann_dim - 2] = q < qe? *q:

;

s.

[ann_dim - 1] = q < (qe-1)? *(q+1):

;

(coord < mrna_size ) {

( ( (

)mrna_size - (

)s.

[1] - 1 ) >= kFlankExonProx &&

seq1_pos = (

)s.

[1];

seq2_pos = (

)s.

[3];

det_pos = s.

.size() - 1;

min_det_pos = det_pos - kMaxCutToSplice;

min_pos = (

)s.

[0] + 8;

(seq1_pos >= min_pos && det_pos >= min_det_pos) {

( (

)(seq2_pos + 2) <

.size() && s.

[det_pos] ==

&&

( det_pos + 1 < s.

.size() ) {

s.

[1] = seq1_pos;

s.

[3] = seq2_pos;

adim = s.

.size();

(adim > 0 && s.

[adim-1] ==

) {

}

(adim > 2 && s.

[adim-3] ==

) {

ss.

[0] = coord;

ss.

[1] = mrna_size - 1;

mcount += jj->m_idty * jj->m_len;

min_singleton_idty_final (

(mcount < min_singleton_idty_final) {

jj->m_box[0] += qmin;

jj->m_box[1] += qmin;

jj->m_box[0] = mrna_size - jj->m_box[0] - 1;

jj->m_box[1] = mrna_size - jj->m_box[1] - 1;

jj->m_box[2] += smin;

jj->m_box[3] += smin;

jj->m_box[2] = smax - jj->m_box[2];

jj->m_box[3] = smax - jj->m_box[3];

severe (

);

TSegmentVector segments;

cerr <<

<< endl;

map_dim (

.size());

cds_start (0), cds_stop (0);

(

(0);

< map_dim; ++

) {

len1 (zone.

[1] - zone.

[0] + 1);

len2 (zone.

[3] - zone.

[2] + 1);

Seq2 + zone.

[2], len2,

vector<size_t> pattern;

);

back_inserter(pattern));

(

j (0), pt_dim (pattern.size()); j < pt_dim; j += 4) {

cerr << (1 + pattern[j]) <<

<< (1 + pattern[j+1]) <<

<<

<< (pattern[j+1] - pattern[j] + 1) <<

<< (1 + pattern[j+2]) <<

<< (1 + pattern[j+3])

<<

<< (pattern[j+3] - pattern[j+2] + 1) <<

pattern[j] -= zone.

[0];

pattern[j+1] -= zone.

[0];

pattern[j+2] -= zone.

[2];

pattern[j+3] -= zone.

[2];

->SetEndSpaceFree(

,

,

,

);

->SetCDS(cds_start, cds_stop);

(

+ 1 < map_dim) {

.m_box[0] = zone.

[1] + 1;

.m_box[2] = zone.

[3] + 1;

cerr <<

<< endl;

(TSegmentVector, ii, segments) {

cerr << ii->m_exon <<

<< ii->m_idty <<

<< ii->m_len <<

<< ii->m_box[0] <<

<< ii->m_box[1] <<

<< ii->m_box[2] <<

<< ii->m_box[3] <<

<< ii->m_annot <<

<< ii->m_score << endl;

(segments.size() == 0) {

SeqLen2 (

.size());

is_test =

;

is_test_plus =

;

is_test_plus =

;

TSegmentVector::iterator

;

(ii->m_exon ==

)

;

(

->m_exon) {

abuts_gap =

( ii->m_box[2] - 1 );

( ii->m_box[0] >

->m_box[1] + 1) {

sgap.

[1] = ii->m_box[0] - 1;

sgap.

[3] = ii->m_box[2] - 1;

ii = segments.insert(ii, sgap);

continue_iterations =

;

(segments.size() == 0) {

exon_count0 (0);

(TSegmentVector, ii, segments) {

(ii->m_exon) ++exon_count0;

first_exon =

;

(

k0 = 0; k0 < segments.size(); ++k0) {

first_exon =

;

}

( !segments[k0-1].m_exon ) {

(last_exon ==

) {

TSegmentVector tmp_segments;

prev_exon_index = -1;

(

k0 = 0; k0 < segments.size(); ++k0) {

(segments[k0].m_exon) {

(prev_exon_index == -1) {

(segments[k0].m_box[0] > 0) {

.m_box[1] = segments[k0].m_box[0] - 1;

.m_box[3] = segments[k0].m_box[2] - 1;

.m_len =

.m_box[1] -

.m_box[0] + 1;

tmp_segments.push_back(

);

( segments[prev_exon_index].m_box[1] + 1 < segments[k0].m_box[0] ) {

.m_box[0] = segments[prev_exon_index].m_box[1] + 1;

.m_box[1] = segments[k0].m_box[0] - 1;

.m_box[2] = segments[prev_exon_index].m_box[3] + 1;

.m_box[3] = segments[k0].m_box[2] - 1;

.m_len =

.m_box[1] -

.m_box[0] + 1;

tmp_segments.push_back(

);

prev_exon_index = (

)k0;

tmp_segments.push_back(segments[k0]);

(prev_exon_index >= 0) {

(segments[prev_exon_index].m_box[1] + 1 < SeqLen1) {

.m_box[0] = segments[prev_exon_index].m_box[1] + 1;

.m_box[1] = SeqLen1 - 1;

.m_box[2] = segments[prev_exon_index].m_box[3] + 1;

.m_box[3] = SeqLen2 - 1;

.m_len =

.m_box[1] -

.m_box[0] + 1;

tmp_segments.push_back(

);

segments.swap(tmp_segments);

(k0 < segments.size()) {

min_idty (

>= kMinTermExonSize?

(s.

>= min_idty) {

k1 (segments.size() - 1);

(k1 >= (

)k0) {

min_idty (

>= kMinTermExonSize?

(s.

>= min_idty) {

ii->ImproveFromLeft1(Seq1, Seq2,

);

ii->ImproveFromRight1(Seq1, Seq2,

);

(

k0 = 0; k0 < segments.size(); ++k0) {

(!segments[k0].m_exon) {

( k0 > 0 && segments[k0-1].m_exon) {

(

(segments[k0-1].m_box[3] + 1) ||

( ( (

)SeqLen1 - (

)segments[k0-1].m_box[1] - 1 ) >= kFlankExonProx ) {

segments[k0-1].ImproveFromRight1(Seq1, Seq2,

);

segments[k0-1].ImproveFromRight(Seq1, Seq2,

);

( k0 + 1 < segments.size() && segments[k0+1].m_exon) {

(

(segments[k0+1].m_box[2] - 1) ||

( (

)segments[k0+1].m_box[0] >= kFlankExonProx ) {

segments[k0+1].ImproveFromLeft1(Seq1, Seq2,

);

segments[k0+1].ImproveFromLeft(Seq1, Seq2,

);

( segments.size() == 0 ) {

(segments[0].m_box[0] > 0) {

.m_box[1] = segments[0].m_box[0] - 1;

.m_box[3] = segments[0].m_box[2] - 1;

segments.insert(segments.begin(),

);

& seg_last (segments.back());

(seg_last.

[1] + 1 < SeqLen1) {

.m_box[0] = seg_last.

[1] + 1;

.m_box[1] = SeqLen1 - 1;

.m_box[2] = seg_last.

[3] + 1;

.m_box[3] = SeqLen2 - 1;

segments.push_back(

);

first_exon =

;

(ii->IsLowComplexityExon(Seq1) ) {

first_exon =

;

( last_exon != 0 ) {

(ii->m_exon ==

)

;

sl.ImproveFromLeft1(Seq1, Seq2,

);

( sl.m_details == ii->m_details && sr.

== ii->m_details ) {

( sr.

!= ii->m_details && ii != segments.begin() && (ii-1)->m_exon && ( (ii+1) == segments.end() || !(ii+1)->m_exon ) ) {

}

( sl.m_details != ii->m_details && (ii+1) != segments.end() && (ii+1)->m_exon && ( ii == segments.begin() || !(ii-1)->m_exon) ) {

}

(sl.m_details == ii->m_details ||

(sl.m_details != ii->m_details || sr.

!= ii->m_details){

(sl.m_details == ii->m_details ||

(ii != segments.begin() && (ii)->m_box[0] > (ii - 1)->m_box[1] + 1) {

sgap.

[0] = (ii - 1)->m_box[1] + 1;

sgap.

[2] = (ii - 1)->m_box[3] + 1;

sgap.

[1] = ii->m_box[0] - 1;

sgap.

[3] = ii->m_box[2] - 1;

ii = segments.insert(ii, sgap);

continue_iterations =

;

( (ii+1) != segments.end() && (ii+1)->m_box[0] > ii->m_box[1] + 1 ) {

sgap.

[0] = (ii - 1)->m_box[1] + 1;

sgap.

[2] = (ii - 1)->m_box[3] + 1;

sgap.

[1] = ii->m_box[0] - 1;

sgap.

[3] = ii->m_box[2] - 1;

ii = segments.insert(ii, sgap);

continue_iterations =

;

}

(ii->m_idty < .9 && ii->m_len < 20) {

nc_prev (

), nc_next (

);

(ii != segments.begin() && (ii - 1)->m_exon) {

( (ii+1) != segments.end() && (ii + 1)->m_exon) {

(ii + 1)->GetAcceptor());

( nc_prev || nc_next ) {

(

k (0); k < segments.size(); ++k) {

(s.

==

)

;

( ( k == 0 ) || ( ! segments[k-1].m_exon ) ) {

( ( k + 1 == segments.size() ) || ( ! segments[k+1].m_exon ) ) {

(

k (0); k < segments.size(); ++k) {

(s.

==

)

;

drop (

);

( (

)s.

[0] >= kFlankExonProx ) {

(adj ==

) adj = eSoft;

( k + 1 == segments.size() ) {

( ( (

)SeqLen1 - (

)s.

[1] - 1 ) >= kFlankExonProx ) {

(adj ==

) adj = eSoft;

(k > 0 && ( ! segments[k-1].m_exon ) ) {

( (

)s.

[0] >= kFlankExonProx ) {

(adj ==

) adj = eSoft;

(k + 1 < segments.size() && (! segments[k+1].m_exon ) ) {

( ( (

)SeqLen1 - (

)s.

[1] - 1 ) >= kFlankExonProx ) {

(adj ==

) adj = eSoft;

}

(adj == eHard) {

( s.

< 20 ) {

( s.

< kMinTermExonIdty && s.

< kMinTermExonSize ) {

exon_count (0);

(

= 0;

< segments.size(); ++

) {

term_segs[exon_count] = &s;

(++exon_count == 2) {

(exon_count == 2) {

exon_count (0);

(

= segments.size() - 1;

>= 0; --

) {

term_segs[exon_count] = &s;

(++exon_count == 2) {

(exon_count == 2) {

gap_prev (

);

(

k (0); k < segments.size(); ++k) {

(s.

==

) {

length (s.

[1] - s.

[0] + 1);

gap_next (

);

(k + 1 < segments.size()) {

gap_next = !segments[k+1].m_exon;

(length <= 10 && (gap_prev || gap_next)) {

gap_start_idx (-1);

(segments.size() && segments[0].m_exon ==

) {

(

k (0); k < segments.size(); ++k) {

(gap_start_idx == -1) {

gap_start_idx =

(k);

s.

[0] = segments[k-1].m_box[1] + 1;

s.

[2] = segments[k-1].m_box[3] + 1;

(gap_start_idx >= 0) {

.m_box[1] = s.

[0] - 1;

.m_box[3] = s.

[2] - 1;

.m_len =

.m_box[1] -

.m_box[0] + 1;

.m_details.resize(0);

(gap_start_idx >= 0) {

.m_box[1] = segments[segments.size()-1].m_box[1];

.m_box[3] = segments[segments.size()-1].m_box[3];

.m_len =

.m_box[1] -

.m_box[0] + 1;

.m_details.resize(0);

exon_count1 (0);

(ii->m_exon) ++exon_count1;

(exon_count1 == 0 ) {

(exon_count0 == exon_count1 && continue_iterations ==

)

;

first_exon =

;

last_exon_index = -1;

(

k0 = 0; k0 < sdim; ++k0) {

last_exon_index = (

)k0;

(

k0 = 0; k0 < sdim; ++k0) {

cut_from_left =

;

cut_from_right =

;

first_exon =

;

( (

)s.

[0] >= kFlankExonProx ) {

cut_from_left =

;

first_exon =

;

cut_from_left =

;

( last_exon_index == (

)k0 ) {

( ( (

)SeqLen1 - (

)s.

[1] - 1 ) >= kFlankExonProx ) {

cut_from_right =

;

}

(k0 + 1 < sdim && (!

[k0+1].m_exon ) ) {

cut_from_right =

;

(cut_from_left) {

seq1_pos = (

)s.

[0];

seq2_pos = (

)s.

[2];

max_pos = (

)s.

[1] - 8;

(seq1_pos <= max_pos && det_pos <= kMaxCutToSplice) {

( seq2_pos > 1 && s.

[det_pos] ==

&&

(Seq2[seq2_pos-2]) ==

&&

(Seq2[seq2_pos-1]) ==

) {

s.

[0] = seq1_pos;

s.

[2] = seq2_pos;

( k0>0 && ( !

[k0-1].m_exon ) ) {

.m_box[1] = s.

[0] - 1;

.m_box[3] = s.

[2] - 1;

.m_len =

.m_box[1] -

.m_box[0] + 1;

(cut_from_right) {

seq1_pos = (

)s.

[1];

seq2_pos = (

)s.

[3];

det_pos = s.

.size() - 1;

min_det_pos = det_pos - kMaxCutToSplice;

min_pos = (

)s.

[0] + 8;

(seq1_pos >= min_pos && det_pos >= min_det_pos) {

( (

)(seq2_pos + 2) <

.size() && s.

[det_pos] ==

&&

(Seq2[seq2_pos+1]) ==

&&

(Seq2[seq2_pos+2]) ==

) {

( det_pos + 1 < s.

.size() ) {

s.

[1] = seq1_pos;

s.

[3] = seq2_pos;

adim = s.

.size();

(adim > 0 && s.

[adim-1] ==

) {

}

(adim > 2 && s.

[adim-3] ==

) {

( k0 + 1 < sdim && ( !

[k0+1].m_exon ) ) {

.m_box[0] = s.

[1] + 1;

.m_box[2] = s.

[3] + 1;

.m_len =

.m_box[1] -

.m_box[0] + 1;

adjust =

;

prev_exon =

;

(

pp = 0; pp <ssize ; ++pp) {

( !prev_exon && ( pp == ssize - 1 || !

[pp+1].m_exon ) ) {

( min_hole_len > 0) {

(; pos2 <

.size(); ++pos1, ++pos2) {

cut_to_codons =

;

( cut_to_codons ) {

cerr <<

<< endl;

cerr << ii->m_box[0] <<

<< ii->m_box[1] <<

<< ii->m_box[2] <<

<< ii->m_box[3] <<

<< ii->m_annot <<

<< ii->m_score << endl;

(

(0), dim (

.size());

< dim; ++

) {

trans.append(s.

,

);

(

, ii, trans) {

double(matches) / trans.size();

box[1] = box[3] = 0;

box[0] =

(

);

box[1] =

(

);

box[2] =

(

);

box[3] =

(

);

turn2gap (

);

exon_size (1 + term_segs[0]->m_box[1] -

term_segs[0]->m_box[0]);

idty (term_segs[0]->m_idty);

(exon_size < kMinTermExonSize && idty < kMinTermExonIdty ) {

(exon_size < kMinTermExonSize) {

*dnr, *acc;

= term_segs[0]->

[3];

= term_segs[1]->

[2];

= term_segs[1]->

[3];

= term_segs[0]->

[2];

intron_len (

-

);

max_ext ((idty < .96 || !consensus || exon_size < 16)?

(exon_size < 8) {

max_ext = 10 * exon_size;

(exon_size < 16) {

(intron_len > max_intron_len) {

s.

= exon_size;

(query_len >= kNonCoveredEndThreshold) {

k (pow(kNonCoveredEndThreshold, - 1. / kPower) * max_ext);

drv (k * pow(query_len, 1. / kPower));

<

T>

*(

*

(p)) =

;

(s.begin(), s.end(), p);

<

T>

= *(

*

(p));

=

m_exon +

m_idty +

m_len +

m_box + m_annot.size() + 1 +

m_details.size() + 1 +

m_score;

* p = &target->front();

(

= 0;

< 4; ++

) {

min_size =

m_exon +

m_idty +

m_len +

+

m_box + 1 + 1 +

m_score;

(

.size() < min_size) {

* p = &

.front();

(

= 0;

< 4; ++

) {

core_size (

m_Id +

m_Status + m_Msg.size() + 1

+

m_QueryStrand +

m_SubjStrand

+

m_Cds_start +

m_Cds_stop

vector<char> core (core_size);

* p = &core.front();

vector<TNetCacheBuffer> TBuffers;

TBuffers vb (m_Segments.size());

ii->ToBuffer(&vb[ibuf++]);

(core_size +

(

) * m_Segments.size());

TNetCacheBuffer::iterator it = target->begin();

(core.begin(), core.end(), it);

seg_buf_size = ii->size();

*((

*)p) = seg_buf_size;

it +=

(size_t);

(ii->begin(), ii->end(), it);

min_size (

+

m_QueryStrand +

m_SubjStrand

+

m_Cds_start +

m_Cds_stop

(

.size() < min_size) {

* p (&

.front());

* pe (&

.back());

seg_buf_size (0);

m_Segments.push_back(

());

& seg (m_Segments.back());

valid_input (sas.

() && sas->CanGet() && sas->Get().size()

&& sas->Get().front()->CanGetSegs()

&& sas->Get().front()->GetSegs().IsSpliced()

&& sas->Get().front()->GetSegs().GetSpliced().GetProduct_type()

);

output_stats->resize(0);

output_stats->push_back(ss);

output_stats->size();

kFrame_not_set (-10);

kFrame_end (-5);

kFrame_lost (-20);

embed_scoreset,

);

cds_stats ((

&

) && (cds.first + cds.second > 0));

scores.assign(score_vec.begin(), score_vec.end());

TSpliced & spliced (sa->GetSegs().GetSpliced());

);

cds_strand (cds.first < cds.second);

(qstrand ^ cds_strand) {

);

TSpliced::TExons TExons;

TExons & exons (spliced.GetExons());

qlen (spliced.GetProduct_length());

polya (spliced.CanGetPoly_a()?

spliced.GetPoly_a(): (qstrand? qlen:

(-1)));

(TExons, ii2, exons) {

TExon & exon (**ii2);

qmin (exon.GetProduct_start().GetNucpos()),

qmax (exon.GetProduct_end().GetNucpos());

qgap (qstrand? qmin - qprev - 1: qprev - qmax - 1);

(cds_stats) xcript.append(qgap,

);

TExon::TParts TParts;

TParts & parts (exon.GetParts());

(TParts, ii3, parts) {

(cds_stats) xcript.append(

,

);

(cds_stats) xcript.append(

,

);

(cds_stats) xcript.append(

,

);

(cds_stats) xcript.append(

,

);

errmsg =

qprev = qstrand? qmax: qmin;

qgap (qstrand? polya - qprev - 1: qprev - polya - 1);

(cds_stats) xcript.append(qgap,

);

(!qstrand && qlen <= 0) {

);

qpos (qstrand? -1:

(qlen));

qinc (qstrand? +1: -1);

frame (kFrame_not_set);

aln_length_cds (0);

matches_frame[] = {0, 0, 0, 0, 0};

cds_start (cds.first), cds_stop (cds.second);

(string::const_iterator ie (xcript.end()), ii(xcript.begin());

ii != ie && frame != kFrame_end; ++ii)

(frame == kFrame_not_set && qpos == cds_start) frame = 0;

(qpos == cds_stop) frame = kFrame_end;

++matches_frame[frame + 2];

(frame == kFrame_not_set && qpos == cds_start) frame = 0;

(qpos == cds_stop) frame = kFrame_end;

(frame >= -2) ++aln_length_cds;

(frame == kFrame_not_set && qpos == cds_start) frame = 0;

(qpos == cds_stop) frame = kFrame_end;

frame = (frame + 1) % 3;

frame = (frame - 1) % 3;

( (qstrand && cds_start <= qpos && qpos < cds_stop) ||

(!qstrand && cds_start >= qpos && qpos > cds_stop) )

frame = kFrame_lost;

score_matches_inframe->SetValue().SetInt(matches_frame[2]);

scores.push_back(score_matches_inframe);

score_inframe_identity->SetValue().

SetReal(

(matches_frame[2]) / aln_length_cds);

scores.push_back(score_inframe_identity);

(embed_scoreset) {

sa_score.resize(scores.size());

(scores.begin(), scores.end(), sa_score.begin());

@ eExtreme_Positional

numerical value

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

void remove_if(Container &c, Predicate *__pred)

void transform(Container &c, UnaryFunction *op)

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

Execute: identify compartments.

bool GetStrand(size_t i) const

void SetMaxIntron(TCoord mi)

Assign the maximum intron length, in base pairs.

void Get(size_t idx, THitRefs &compartment) const

Retrieve a compartment by index.

const TCoord * GetBox(size_t i) const

bool GetStatus(size_t i) const

pair< size_t, size_t > GetCounts(void) const

Retrieve the compartment counts.

CNcbiOstrstreamToString class helps convert CNcbiOstrstream to a string Sample usage:

static void FindOrfs(const string &seq, TLocVec &results, unsigned int min_length_bp=3, int genetic_code=1, const vector< string > &allowable_starts=vector< string >(), bool longest_orfs=true, size_t max_seq_gap=k_default_max_seq_gap)

Find ORFs in both orientations.

bool IntersectingWith(const TRange &r) const

void AddSplignScores(const CSeq_align &align, CSeq_align::TScore &scores)

Compute the six splign scores.

void ImproveFromLeft(TSeg &s)

void Cut50FromLeft(TSeg &s)

static bool HasAbuttingExonOnLeft(TSegs segments, TSeqPos p)

void Cut50FromRight(TSeg &s)

void TrimHolesToCodons(TSegs &segments, objects::CBioseq_Handle &mrna_bio_handle, bool mrna_strand, TSeqPos mrna_len)

void ImproveFromRight(TSeg &s)

bool ThrowAway20_28_90(TSeg &s)

void JoinExons(TSegs &segments, TSeqPos p1, TSeqPos p2)

void AdjustGaps(TSegs &segments)

static bool HasAbuttingExonOnRight(TSegs segments, TSeqPos p)

void SetMismatchScore(int score)

void SetMinHoleLen(size_t len)

void SetPolyaDetection(bool on)

static int s_GetDefaultNonConsensusSpliceScore(void)

int GetGcAgSpliceScore(void) const

EScoringType GetScoringType(void) const

void Run(THitRefs *hitrefs)

void SetCompartmentPenalty(double penalty)

int m_NonConsensusSpliceScore

int GetGapExtensionScore(void) const

list< CRef< objects::CScore_set > > TScoreSets

void SetMinSingletonIdentity(double idty)

size_t x_GetGenomicExtent(const size_t query_extent, size_t max_ext=0) const

CRef< objects::CScope > & SetScope(void)

void SetMatchScore(int score)

void SetMinPolyaLen(size_t len)

SAlignedCompartment x_RunOnCompartment(THitRefs *hitrefs, size_t range_left, size_t range_right)

void SetMaxIntron(size_t max_intron)

bool GetEndGapDetection(void) const

double GetPolyaExtIdentity(void) const

static bool s_GetDefaultTrimToCodons(void)

size_t m_MinSingletonIdtyBps

bool x_ProcessTermSegm(TSegment **term_segs, Uint1 side) const

void SetMinSingletonIdentityBps(size_t idty)

void SetMinExonIdentity(double idty)

pair< size_t, size_t > m_BoundingRange

static double s_GetDefaultMinCompartmentIdty(void)

size_t GetMinPolyaLen(void) const

int GetMismatchScore(void) const

static int s_GetDefaultGapOpeningScore(void)

void SetGapOpeningScore(int score)

vector< size_t > m_pattern

pair< size_t, size_t > TOrf

static int s_GetDefaultGtAgSpliceScore(void)

CConstRef< objects::CSeqMap > m_GenomicSeqMap

void SetTestType(const string &test_type)

static size_t s_GetDefaultMinPolyaLen(void)

bool GetPolyaDetection(void) const

void SetStrand(bool strand)

double GetCompartmentPenalty(void) const

EScoringType m_ScoringType

size_t GetMinHoleLen(void) const

int GetAtAcSpliceScore(void) const

bool GetTrimToCodons(void) const

void PreserveScope(bool preserve=true)

Controls whether to clean the scope object's cache on a new sequence.

void SetMaxPartExonIdentDrop(double ident)

void SetGcAgSpliceScore(int score)

static size_t s_GetDefaultMaxGenomicExtent(void)

vector< char > m_mrna_polya

size_t m_MaxCompsPerQuery

bool AlignSingleCompartment(THitRefs *hitrefs, THit::TCoord range_left, THit::TCoord range_right, SAlignedCompartment *result)

void SetMaxCompsPerQuery(size_t m)

void x_LoadSequence(vector< char > *seq, const objects::CSeq_id &seqid, THit::TCoord start, THit::TCoord finish, bool retain, bool is_genomic=false, bool genomic_strand=true)

size_t GetMaxIntron(void) const

static CVersionAPI & s_GetVersion(void)

Retrieve the library's version object.

bool GetStrand(void) const

string GetTestType(void) const

CRef< objects::CScope > GetScope(void) const

Access the scope object that the library will use to retrieve the sequences.

static int s_GetDefaultGcAgSpliceScore(void)

void SetScoringType(EScoringType type)

double m_MinSingletonIdty

CRef< objects::CScope > m_Scope

void SetNonConsensusSpliceScore(int score)

static double s_GetDefaultCompartmentPenalty(void)

vector< THitRef > THitRefs

void SetAlignerScores(void)

static int s_GetDefaultMatchScore(void)

static double s_GetDefaultMinExonIdty(void)

void SetMaxGenomicExtent(size_t mge)

static int s_GetDefaultMismatchScore(void)

size_t GetMaxGenomicExtent(void) const

static double s_GetDefaultMaxPartExonIdentDrop(void)

static size_t s_ComputeStats(CRef< objects::CSeq_align_set > sas, TScoreSets *output_stats, TOrf cds=TOrf(0, 0), EStatFlags flags=eSF_BasicNonCds)

Generate statistics based on splign-generated seq-align-set, with each seq-align corresponding to an ...

double m_MinCompartmentIdty

CConstRef< TAligner > GetAligner(void) const

void x_FinalizeAlignedCompartment(SAlignedCompartment &ac)

double GetMinCompartmentIdentity(void) const

static EScoringType s_GetDefaultScoringType(void)

static size_t s_TestPolyA(const char *seq, size_t dim, size_t cds_stop=0)

void x_SplitQualifyingHits(THitRefs *phitrefs)

size_t GetMaxCompsPerQuery(void) const

double m_MaxPartExonIdentDrop

void SetTrimToCodons(bool)

int GetMatchScore(void) const

void SetAtAcSpliceScore(int score)

bool IsPolyA(const char *seq, size_t polya_start, size_t dim)

void SetPolyaExtIdentity(double idty)

size_t m_MinPatternHitLength

void SetGapExtensionScore(int score)

double GetMinSingletonIdentity(void) const

CRef< TAligner > & SetAligner(void)

Access the spliced aligner core object.

float x_Run(const char *seq1, const char *seq2)

size_t GetMinSingletonIdentityBps(void) const

bool x_IsInGap(size_t pos)

TSIHToMaskRanges m_MaskMap

static double s_GetDefaultPolyaExtIdty(void)

void SetMinCompartmentIdentity(double idty)

vector< TSegment > TSegments

static CRef< CSplicedAligner > s_CreateDefaultAligner(void)

int GetNonConsensusSpliceScore(void) const

TOrfPair GetCds(const THit::TId &id, const vector< char > *seq_data=0)

double m_CompartmentPenalty

pair< TOrf, TOrf > TOrfPair

void SetEndGapDetection(bool on)

int GetGtAgSpliceScore(void) const

objects::CBioseq_Handle m_mrna_bio_handle

double GetMaxPartExonIdentDrop(void) const

static size_t s_GetDefaultMinHoleLen(void)

void SetGtAgSpliceScore(int score)

int GetGapOpeningScore(void) const

void x_SetPattern(THitRefs *hitrefs)

double GetMinExonIdentity(void) const

CRef< TAligner > m_aligner

static THitRef sx_NewHit(THit::TCoord q0, THit::TCoord q, THit::TCoord s0, THit::TCoord s)

CNWFormatter::SSegment TSegment

static int s_GetDefaultAtAcSpliceScore(void)

void x_MaskSequence(vector< char > *seq, const TSeqRangeColl &mask_ranges, THit::TCoord start, THit::TCoord finish)

static int s_GetDefaultGapExtensionScore(void)

vector< SAlnMapElem > m_alnmap

container_type::const_iterator const_iterator

const_iterator end() const

const_iterator find(const key_type &key) const

static const char s_Version[]

static void test_type(TDSSOCKET *tds, TDSCOLUMN *col)

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

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

void ImproveFromLeft(const char *seq1, const char *seq2, CConstRef< CSplicedAligner > aligner)

void ExtendRight(const vector< char > &mrna, const vector< char > &genomic, Int8 ext_len, const CNWAligner *aligner)

void ImproveFromRight(const char *seq1, const char *seq2, CConstRef< CSplicedAligner > aligner)

void AsText(string *output, ETextFormatType type, size_t line_width=100) const

void MakeSegments(vector< SSegment > *psegments) const

int CanExtendRight(const vector< char > &mrna, const vector< char > &genomic) const

const char * GetDonor(void) const

void ImproveFromRight1(const char *seq1, const char *seq2, CConstRef< CSplicedAligner > aligner)

void FromBuffer(const TNetCacheBuffer &buf)

static bool s_IsConsensusSplice(const char *donor, const char *acceptor, bool semi_as_cons=false)

void ToBuffer(TNetCacheBuffer *buf) const

vector< char > TNetCacheBuffer

const char * GetAcceptor(void) const

int CanExtendLeft(const vector< char > &mrna, const vector< char > &genomic) const

void Update(const CNWAligner *aligner)

void ExtendLeft(const vector< char > &mrna, const vector< char > &genomic, Int8 ext_len, const CNWAligner *aligner)

bool IsLowComplexityExon(const char *rna_seq)

void SetBand(size_t band)

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

size_t GetLongestSeg(size_t *q0, size_t *q1, size_t *s0, size_t *s1) const

static void s_GetSpan(const THitRefs &hitrefs, TCoord span[4])

Get sequence span for a set of alignments (hits).

void SetScoreMatrix(const SNCBIPackedScoreMatrix *scoremat)

void SetWms(TScore value)

void SetWi(unsigned char splice_type, TScore value)

unsigned int TSeqPos

Type for sequence locations and lengths.

#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 NON_CONST_REVERSE_ITERATE(Type, Var, Cont)

Non constant version of REVERSE_ITERATE macro.

@ eDiag_Fatal

Fatal error – guarantees exit(or abort)

TErrCode GetErrCode(void) const

Get error code.

#define NCBI_THROW(exception_class, err_code, message)

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

const string & GetMsg(void) const

Get message string.

#define NCBI_RETHROW_SAME(prev_exception, message)

Generic macro to re-throw the same exception.

EDiagSev GetSeverity(void) const

Get exception severity.

CException & SetSeverity(EDiagSev severity)

Set exception severity.

const string AsFastaString(void) const

string GetSeqIdString(bool with_version=false) const

Return seqid string with optional version for text seqid type.

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

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

static CSeq_id_Handle GetHandle(const CSeq_id &id)

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

TSeqPos GetStart(ESeqLocExtremes ext) const

Return start and stop positions of the seq-loc.

TSeqPos GetStop(ESeqLocExtremes ext) const

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

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

CSeqVector GetSeqVector(EVectorCoding coding, ENa_strand strand=eNa_strand_plus) const

Get sequence: Iupacna or Iupacaa if use_iupac_coding is true.

@ eCoding_Iupac

Set coding to printable coding (Iupacna or Iupacaa)

TSeqPos GetEndPosition(void) const

return end position of current segment in sequence (exclusive)

CSeqMap::ESegmentType GetType(void) const

TSeqPos GetPosition(void) const

return position of current segment in sequence

CConstRef< CSeq_literal > GetRefGapLiteral(void) const

return CSeq_literal with gap data, or null if either the segment is not a gap, or an unspecified gap

void GetSeqData(TSeqPos start, TSeqPos stop, string &buffer) const

Fill the buffer string with the sequence data for the interval [start, stop).

static CConstRef< CSeqMap > GetSeqMapForSeq_loc(const CSeq_loc &loc, CScope *scope)

CSeqMap_CI ResolvedRangeIterator(CScope *scope, TSeqPos from, TSeqPos length, ENa_strand strand=eNa_strand_plus, size_t maxResolve=size_t(-1), TFlags flags=fDefaultFlags) const

Iterate segments in the range with specified strand coordinates.

bool NotNull(void) const THROWS_NONE

Check if pointer is not null – same effect as NotEmpty().

TObjectType * GetPointer(void) THROWS_NONE

Get pointer,.

void Reset(void)

Reset reference object.

bool IsNull(void) const THROWS_NONE

Check if pointer is null – same effect as Empty().

uint8_t Uint1

1-byte (8-bit) unsigned integer

int32_t Int4

4-byte (32-bit) signed integer

#define numeric_limits

Pre-declaration of the "numeric_limits<>" template Forcibly overrides (using preprocessor) the origin...

uint32_t Uint4

4-byte (32-bit) unsigned integer

int64_t Int8

8-byte (64-bit) signed integer

TThisType & SetLength(position_type length)

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

void SetFrom(TFrom value)

Assign a value to From data member.

E_Choice

Choice variants.

vector< CRef< CScore > > TScore

TMatch GetMatch(void) const

Get the variant data.

list< CRef< CScore > > Tdata

Tdata & Set(void)

Assign a value to data member.

static string SelectionName(E_Choice index)

Retrieve selection name (for diagnostic purposes).

TMismatch GetMismatch(void) const

Get the variant data.

TGenomic_ins GetGenomic_ins(void) const

Get the variant data.

list< CRef< CSeq_align > > Tdata

TProduct_ins GetProduct_ins(void) const

Get the variant data.

E_Choice Which(void) const

Which variant is currently selected.

@ e_Product_ins

insertion in product sequence (i.e. gap in the genomic sequence)

@ e_Genomic_ins

insertion in genomic sequence (i.e. gap in the product sequence)

@ e_Match

both sequences represented, product and genomic sequences match

@ e_Mismatch

both sequences represented, product and genomic sequences do not match

@ eProduct_type_transcript

ENa_strand

strand of nucleic acid

unsigned int

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

const CharType(& source)[N]

void ElemToBuffer(const string &s, char *&p)

void ElemFromBuffer(string &s, const char *&p)

Int4 delta(size_t dimension_, const Int4 *score_)

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

string GetDonor(const objects::CSpliced_exon &exon)

static sljit_uw total_size

static const sljit_gpr r1

static const sljit_gpr r2

static CVersionAPI * s_CreateVersion(void)

const string kTestType_20_28

const string kTestType_20_28_plus

const string kTestType_production_default

void CleaveOffByTail(CSplign::THitRefs *phitrefs, TSeqPos polya_start)

const char g_msg_NoAlignment[]

const char g_msg_CompartmentInconsistent[]

const char g_msg_AlignedNotSpecified[]

const char g_msg_BadIdentityThreshold[]

const char g_msg_EmptyHitVectorPassed[]

const char g_msg_NetCacheBufferIncomplete[]

const char g_msg_QueryCoverageOutOfRange[]

const char g_msg_NullPointerPassed[]

const char g_msg_NoExonsAboveIdtyLimit[]

const char g_msg_NoHitsAfterFiltering[]

const char g_msg_InvalidRange[]

ECompartmentStatus m_Status

vector< char > TNetCacheBuffer

void GetBox(Uint4 *box) const

void ToBuffer(TNetCacheBuffer *buf) const

void FromBuffer(const TNetCacheBuffer &buf)

double GetIdentity(void) const

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

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