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

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

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

in_quotes =

;

in_space =

;

(

= 0;

< s.size(); ++

) {

((c ==

|| c ==

) && !in_quotes) {

(c ==

|| c ==

) {

(c == quote_char) {

runtime_error(

);

vector<CContigAssembly::SAlignStats::STails>& tails)

(

j = 0; j < vec.

(); ++j) {

tls.

= seq_len - stop - 1;

tls.

= seq_len - stop - 1;

tails.push_back(tls);

& param_string,

query_loc.

().Assign(query_id);

subject_loc.

().Assign(subject_id);

(query_loc, subject_loc, param_string, scope);

& param_string,

query_sl(query_loc, scope);

subject_sl(subject_loc, scope);

(

= 0;

< args.size();

+= 2) {

& name = args[

];

(

+ 1 >= args.size()) {

runtime_error(

+ name);

&

= args[

+ 1];

}

(name ==

) {

}

(name ==

) {

}

(name ==

) {

}

(name ==

) {

}

(name ==

) {

}

(name ==

) {

}

(name ==

) {

runtime_error(

+ name);

vector<unsigned int>& plus_vec,

vector<unsigned int>& minus_vec)

*align_set.

().front()->GetSegs().GetDenseg().GetIds()[0];

*align_set.

().front()->GetSegs().GetDenseg().GetIds()[1];

plus_vec.resize(len0 + len1);

minus_vec.resize(len0 + len1);

& ds = (*aln)->GetSegs().GetDenseg();

(start0 == -1 || start1 == -1) {

diag = (start0 + seg_len - 1) + start1;

minus_vec[diag] += seg_len;

& ds = (*aln)->GetSegs().GetDenseg();

(start0 == -1 || start1 == -1) {

diag = start1 - start0 + len0 - 1 ;

plus_vec[diag] += seg_len;

vector<TRange>& max_range)

running_sum = 0;

(

= 0;

< window; ++

) {

running_sum += vec[

];

max_range.push_back(

(window - 1, window - 1));

(

= window;

< vec.size(); ++

) {

running_sum -= vec[

- window];

running_sum += vec[

];

(running_sum >=

) {

(running_sum >

) {

(max_range.size() && max_range.back().GetFrom() ==

- 1) {

max_range.back().SetFrom(

);

max_range.push_back(

(

,

));

vector<unsigned int> plus_vec, minus_vec;

(align_set, scope, plus_vec, minus_vec);

plus_count;

vector<TRange> plus_range;

minus_count;

vector<TRange> minus_range;

vector<TRange>*

=

;

(plus_count > minus_count) {

(

->front().GetFrom() +

->front().GetTo() + 1) / 2 -

/ 2;

half_width,

& scope)

(diag <= seq0.size()) {

shift = seq0.size() - 1 - diag;

shift = diag - (seq0.size() - 1);

ds->

().push_back(cr_id0);

ds->

().push_back(cr_id1);

(

= 0;

< ds->

().

() - 1; ++

) {

slop,

& scope)

( (

.tails[0].right <= slop &&

.tails[1].left <= slop) ||

(

.tails[0].left <= slop &&

.tails[1].right <= slop) ) {

slop,

& scope)

slop,

& scope)

FirstContainsSecond;

SecondContainsFirst;

FirstContainsSecond = ((((long)

.tails[0].left -

.tails[1].left) >= -

(slop)) &&

(((

)

.tails[0].right -

.tails[1].right) >= -

(slop)));

SecondContainsFirst = ((((long)

.tails[1].left -

.tails[0].left) >= -

(slop)) &&

(((

)

.tails[1].right -

.tails[0].right) >= -

(slop)));

(FirstContainsSecond | SecondContainsFirst);

Ident =

.pct_identity/100.0;

Wg = -5, Wm = 1, Wms = -2, Ws = -2;

(

= 0;

< ds_in.

().

(); ++

) {

vector<int> scores(sz);

(

= 0;

< scores.size(); ++

) {

previous_score = scores[

- 1];

scores[

] = previous_score + Ws;

scores[

] = previous_score + Wg + Ws;

}

(res1 ==

) {

scores[

] = previous_score + Ws;

scores[

] = previous_score + Wg + Ws;

}

(res0 == res1) {

scores[

] = previous_score + Wm;

scores[

] = previous_score + Wms;

(scores[

] < 0) {

right_end = 0;

left_end;

(

= 0;

< scores.size(); ++

) {

(scores[

] > max_score) {

max_score = scores[

];

(right_end == 0) {

(

= right_end - 1;

> 0; --

) {

(scores[

] == 0) {

(scores[0] == 0) {

vector<CRef<CSeq_align> >

& blast_params,

min_ident,

max_end_slop,

& scope,

vector<unsigned int>& band_halfwidths,

diag_finding_window,

min_align_length,

(min_ident > 1 || min_ident < 0) {

runtime_error(

*ostr <<

<< min_ident <<

<< max_end_slop

<<

<< min_align_length <<

<<

<< strandmap[strand0] <<

<< strandmap[strand1] << endl;

alns =

(id0, id1, blast_params, scope);

(exception& e) {

*ostr <<

<< e.what() << endl;

vector<CRef<CSeq_align> >();

vector<CRef<CSeq_align> > good_alns;

(

((*aln)->GetSegs().GetDenseg(), max_end_slop, scope)

&&

((*aln)->GetSegs().GetDenseg(), scope) >= min_ident

&&

((*aln)->GetSegs().GetDenseg()) >= min_align_length ) {

good_alns.push_back(*aln);

(!good_alns.empty()) {

*ostr <<

<< good_alns.size() <<

<< blast_params << endl;

*ostr <<

<< blast_params << endl;

(alns->

().empty()) {

*ostr <<

<< endl;

vector<CRef<CSeq_align> >();

(vector<unsigned int>, band_halfwidth, band_halfwidths) {

*ostr <<

<< 2 * *band_halfwidth + 1 << endl;

diag, *band_halfwidth, scope);

*ostr <<

<< e.

() << endl;

*ostr <<

<< endl;

frac_ident =

(*local_ds, scope);

*ostr <<

<< frac_ident << endl;

(

(*local_ds, max_end_slop, scope)

&&

(*local_ds, scope) >= min_ident

*ostr <<

<< endl;

aln->

().SetDenseg(*local_ds);

vector<CRef<CSeq_align> >(1, aln);

*ostr <<

&&

((*aln)->GetSegs().GetDenseg(), scope) >= min_ident

&&

((*aln)->GetSegs().GetDenseg()) >= min_align_length

good_alns.push_back(*aln);

*ostr <<

<< good_alns.size() <<

<< endl;

(!good_alns.empty()) {

&&

(*local_ds, scope) >= min_ident

dovetail_string;

(

(*local_ds, max_end_slop, scope)) {

dovetail_string =

;

dovetail_string =

;

*ostr <<

<< dovetail_string <<

<< endl;

aln->

().SetDenseg(*local_ds);

vector<CRef<CSeq_align> >(1, aln);

*ostr <<

<< endl;

vector<CRef<CSeq_align> >();

objects::CScope& scope)

(row1.size() == row2.size());

(

= 0;

< row1.size(); ++

) {

(row1[

] !=

&& row2[

] !=

) {

(row1[

] != row2[

]) {

(row1[

] ==

) {

(

+1 < row1.size() && row1[

+1] ==

) ++

;

}

(row2[

] ==

) {

(

+1 < row1.size() && row2[

+1] ==

) ++

;

align_stats.

.clear();

vector<CRef<CSeq_loc> > dust_locs;

loc->SetPacked_int(*res);

dust_locs.push_back(loc);

simple =

;

is_gap =

;

(

j = 0; j < vec.

(); ++j) {

other_row = (j + 1) % 2;

gap_loc.

().SetId().Set(

);

}

(gap_simple == -1) {

align_stats.

.push_back(simple);

SAlignStats& align_stats)

SAlignStats& align_stats)

(

.tails[0].left <

.tails[1].left) {

matches[2] = {

,

};

(!(matches[0] & matches[1])) {

(matches[0] & matches[1]);

Dim = ds.GetDim();

(

Seg = 0; Seg < Lens.size(); Seg++) {

(Starts[(Seg*Dim)] == -1 || Starts[(Seg*Dim)+1] == -1)

(

= 0;

< vec.GetNumSegs(); ++

) {

is_gap =

;

(

j = 0; j < vec.GetNumRows(); ++j) {

(vec.GetStart(j,

) == -1) {

AlignedLength += vec.GetLen(

);

identities = 0;

(

= 0;

< vec.GetNumSegs(); ++

) {

vec.GetSegSeqString(s1, 0,

);

(

j = 1; j < vec.GetNumRows(); ++j) {

vec.GetSegSeqString(s2, j,

);

(

k = 0; k <

(s1.size(), s2.size()); ++k) {

identities += (s1[k] == s2[k]);

align_stats.

= AlignedLength - identities;

100.0 * double(identities) / double(AlignedLength);

Declares the CBl2Seq (BLAST 2 Sequences) class.

Declares the CBlastNucleotideOptionsHandle class.

Declares the CBlastOptionsHandle and CBlastOptionsFactory classes.

Definitions of special type used in BLAST.

vector< CRef< objects::CSeq_align_set > > TSeqAlignVector

Vector of Seq-align-sets.

@ eBlastn

Nucl-Nucl (traditional blastn)

TSignedSeqPos GetStop(TNumrow row, TNumseg seg, int offset=0) const

TSignedSeqPos GetStart(TNumrow row, TNumseg seg, int offset=0) const

bool IsPositiveStrand(TNumrow row) const

TSignedSeqPos GetSeqPosFromAlnPos(TNumrow for_row, TSeqPos aln_pos, ESearchDirection dir=eNone, bool try_reverse_dir=true) const

TDim GetNumRows(void) const

TSeqPos GetAlnStop(TNumseg seg) const

TSeqPos GetLen(TNumseg seg, int offset=0) const

TSeqPos GetSeqStop(TNumrow row) const

TNumseg GetNumSegs(void) const

TSeqPos GetSeqStart(TNumrow row) const

const CBioseq_Handle & GetBioseqHandle(TNumrow row) const

void SetEndChar(TResidue gap_char)

void SetGapChar(TResidue gap_char)

CScope & GetScope(void) const

string & GetAlnSeqString(string &buffer, TNumrow row, const CAlnMap::TSignedRange &aln_rng) const

TResidue GetResidue(TNumrow row, TSeqPos aln_pos) const

Runs the BLAST algorithm between 2 sequences.

Handle to the nucleotide-nucleotide options to the BLAST algorithm.

unsigned int m_AdjustedLen

CAlnStats(unsigned int adjusted_len, unsigned int mm, unsigned int gaps)

static void FindMaxRange(const vector< unsigned int > &vec, unsigned int window, unsigned int &max, vector< TRange > &max_range)

static void x_GatherIdentStats(const objects::CAlnVec &vec, SAlignStats &align_stats)

static CRef< objects::CDense_seg > BestLocalSubAlignment(const objects::CDense_seg &ds_in, objects::CScope &scope)

Find the highest-scoring local subalignment.

static bool IsAtLeastHalfDovetail(const objects::CDense_seg &ds, unsigned int slop, objects::CScope &scope)

static CRef< objects::CSeq_align_set > Blastn(const objects::CSeq_id &query_id, const objects::CSeq_id &subject_id, const string &param_string, objects::CScope &scope)

Utility for running blastn.

static void GatherAlignStats(const objects::CAlnVec &vec, SAlignStats &align_stats)

static bool x_IsAllowedStrands(const objects::CDense_seg &ds, objects::ENa_strand strand0, objects::ENa_strand strand1)

static void FindDiagFromAlignSet(const objects::CSeq_align_set &align_set, objects::CScope &scope, unsigned int window_size, objects::ENa_strand &strand, unsigned int &diag)

Given a set of alignments, pick out a diagonal to use as the center of a band in a banded alignment.

CRange< unsigned int > TRange

Find the range (or more than one tied range) containing the maximal diagonal count,...

static void DiagCounts(const objects::CSeq_align_set &align_set, objects::CScope &scope, vector< unsigned int > &plus_vec, vector< unsigned int > &minus_vec)

Count the cells with "ink" along each diagonal in a dot-matrix-type plot of some set of alignments (e...

static vector< CRef< objects::CSeq_align > > Align(const objects::CSeq_id &id0, const objects::CSeq_id &id1, const string &blast_params, double min_ident, unsigned int max_end_slop, objects::CScope &scope, CNcbiOstream *ostr=0, const vector< unsigned int > &band_halfwidths=vector< unsigned int >(1, 200), unsigned int diag_finding_window=200, unsigned int min_align_length=50, objects::ENa_strand strand0=objects::eNa_strand_unknown, objects::ENa_strand strand1=objects::eNa_strand_unknown)

Most users of the class need only to call this function.

static CRef< objects::CDense_seg > BandedGlobalAlignment(const objects::CSeq_id &id0, const objects::CSeq_id &id1, objects::ENa_strand strand, unsigned int diag, unsigned int half_width, objects::CScope &scope)

Do a banded global alignment using an arbitrary band.

static void x_OrientAlign(objects::CDense_seg &ds, objects::CScope &scope)

static TSeqPos x_DensegLength(const objects::CDense_seg &ds)

static bool IsDovetail(const objects::CDense_seg &ds, unsigned int slop, objects::CScope &scope)

static bool IsContained(const objects::CDense_seg &ds, unsigned int slop, objects::CScope &scope)

static double FracIdent(const objects::CDense_seg &ds, objects::CScope &scope)

ENa_strand GetSeqStrand(TDim row) const

TSeqPos GetSeqStop(TDim row) const

void Reverse(void)

Reverse the segments' orientation.

TSeqPos GetSeqStart(TDim row) const

void FromTranscript(TSeqPos query_start, ENa_strand query_strand, TSeqPos subj_start, ENa_strand subj_strand, const string &transcript)

Initialize from pairwise alignment transcript (a string representation produced by CNWAligner)

CRef< CDense_seg > ExtractSlice(TDim row, TSeqPos from, TSeqPos to) const

Extract a slice of the alignment that includes the specified range.

Looks for low complexity parts of sequences according to the symmetric version of DUST algorithm.

CRef< objects::CPacked_seqint > GetMaskedInts(objects::CSeq_id &seq_id, const sequence_type &seq)

Mask a sequence and return result as a CPacked_seqint instance.

static void s_SplitCommandLine(string s, vector< string > &result)

static void s_GetTails(const CAlnVec &vec, vector< CContigAssembly::SAlignStats::STails > &tails)

void SetSpaceLimit(const size_t &maxmem)

void SetShift(Uint1 where, size_t offset)

string GetTranscriptString(void) const

void SetEndSpaceFree(bool Left1, bool Right1, bool Left2, bool Right2)

void SetEvalueThreshold(double eval)

Sets EvalueThreshold.

void SetMatchReward(int r)

Sets MatchReward.

void SetTraditionalBlastnDefaults()

Sets TraditionalBlastnDefaults.

void SetMismatchPenalty(int p)

Sets MismatchPenalty.

void SetGapXDropoffFinal(double x)

Sets GapXDropoffFinal.

void SetGapExtensionCost(int e)

Sets GapExtensionCost.

void SetFilterString(const char *f, bool clear=true)

Sets FilterString.

void SetWordSize(int ws)

Sets WordSize.

void SetGapOpeningCost(int g)

Sets GapOpeningCost.

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

int TSignedSeqPos

Type for signed sequence position.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

virtual const char * what(void) const noexcept

Standard report (includes full backlog).

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.

sequence::ECompare Compare(const CSeq_loc &loc1, const CSeq_loc &loc2, CScope *scope)

Returns the sequence::ECompare containment relationship between CSeq_locs.

@ fCompareOverlapping

Check if seq-locs are overlapping.

@ eSame

CSeq_locs contain each other.

@ eContained

First CSeq_loc contained by second.

CBioseq_Handle GetBioseqHandle(const CSeq_id &id)

Get bioseq handle by seq-id.

TSeqPos GetBioseqLength(void) const

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

Get sequence: Iupacna or Iupacaa if use_iupac_coding is true.

@ eStrand_Plus

Plus strand.

@ eStrand_Minus

Minus strand.

@ eCoding_Iupac

Set coding to printable coding (Iupacna or Iupacaa)

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

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

void SetIupacCoding(void)

Set coding to either Iupacaa or Iupacna depending on molecule type.

uint8_t Uint1

1-byte (8-bit) unsigned integer

uint64_t Uint8

8-byte (64-bit) unsigned integer

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

IO_PREFIX::ostream CNcbiOstream

Portable alias for ostream.

static string DoubleToString(double value, int precision=-1, TNumToStringFlags flags=0)

Convert double to string.

static int StringToInt(const CTempString str, TStringToNumFlags flags=0, int base=10)

Convert string to int.

static double StringToDouble(const CTempStringEx str, TStringToNumFlags flags=0)

Convert string to double.

const TDenseg & GetDenseg(void) const

Get the variant data.

Tdata & Set(void)

Assign a value to data member.

TLens & SetLens(void)

Assign a value to Lens data member.

const TStarts & GetStarts(void) const

Get the Starts member data.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

const TLens & GetLens(void) const

Get the Lens member data.

vector< TSignedSeqPos > TStarts

void SetType(TType value)

Assign a value to Type data member.

TStarts & SetStarts(void)

Assign a value to Starts data member.

TStrands & SetStrands(void)

Assign a value to Strands data member.

void SetNumseg(TNumseg value)

Assign a value to Numseg data member.

const TIds & GetIds(void) const

Get the Ids member data.

bool CanGetStrands(void) const

Check if it is safe to call GetStrands method.

TNumseg GetNumseg(void) const

Get the Numseg member data.

list< CRef< CSeq_align > > Tdata

TIds & SetIds(void)

Assign a value to Ids data member.

const TStrands & GetStrands(void) const

Get the Strands member data.

const Tdata & Get(void) const

Get the member data.

const TSegs & GetSegs(void) const

Get the Segs member data.

@ eType_partial

mapping pieces together

ENa_strand

strand of nucleic acid

unsigned int

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

const struct ncbi::grid::netcache::search::fields::SIZE size

const GenericPointer< typename T::ValueType > T2 value

Uint8 GetPhysicalMemorySize(void)

Return the amount of physical memory available in the system.

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

#define row(bind, expected)

Alignment characterization.

vector< STails > tails

unaligned tails

double pct_identity

% identity (varies from 0 to 100)

TSeqPos mismatches

number of mismatched bases

TSeqPos total_length

total covered length of the alignment, including gaps

TSeqPos gap_count

count of total number of gaps

vector< bool > is_simple

for each gap, whether is consists of "simple sequence"

vector< TSeqPos > gaps

the set of gap lengths for this alignment

TSeqPos aligned_length

total number of bases included in the alignment

Structure to represent a single sequence to be fed to BLAST.

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