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

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

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

: m_Wm(GetDefaultWm()),

m_Wms(GetDefaultWms()),

m_SmithWaterman(

),

m_GapPreference(eLater),

m_abc(g_nwaligner_nucleotides),

m_ScoreMatrixInvalid(

),

m_Seq1(0), m_SeqLen1(0),

m_Seq2(0), m_SeqLen2(0),

m_PositivesAsMatches(

),

m_MaxMem(GetDefaultSpaceLimit())

* seq2,

len2,

: m_Wm(GetDefaultWm()),

m_Wms(GetDefaultWms()),

m_SmithWaterman(

),

m_GapPreference(eLater),

m_abc(g_nwaligner_nucleotides),

m_ScoreMatrixInvalid(

),

m_Seq1Vec(&seq1[0], &seq1[0]+len1),

m_Seq1(&m_Seq1Vec[0]), m_SeqLen1(len1),

m_Seq2Vec(&seq2[0], &seq2[0]+len2),

m_Seq2(&m_Seq2Vec[0]), m_SeqLen2(len2),

m_PositivesAsMatches(

),

m_MaxMem(GetDefaultSpaceLimit())

: m_Wm(GetDefaultWm()),

m_Wms(GetDefaultWms()),

m_Wg(GetDefaultWg()),

m_Ws(GetDefaultWs()),

m_SmithWaterman(

),

m_GapPreference(eLater),

m_abc(g_nwaligner_nucleotides),

m_ScoreMatrixInvalid(

),

m_terminate(

),

m_Seq1Vec(seq1.begin(), seq1.end()),

m_Seq1(&m_Seq1Vec[0]), m_SeqLen1(seq1.

()),

m_Seq2Vec(seq2.begin(), seq2.end()),

m_Seq2(&m_Seq2Vec[0]), m_SeqLen2(seq2.

()),

m_MaxMem(GetDefaultSpaceLimit())

* seq2,

len2,

(!seq1 || !seq2) {

(iErrPos1 < len1) {

oss <<

<<

<<

<< iErrPos1

<<

<< seq1[iErrPos1] <<

;

(iErrPos2 < len2) {

oss <<

<<

<<

<< iErrPos2

<<

<< seq2[iErrPos2] <<

;

.assign(&seq1[0], &seq1[0]+len1);

.assign(&seq2[0], &seq2[0]+len2);

Left2,

Right2)

);

!

->m_esf_L2 || !

->m_esf_R2 ) ) {

);

N1 =

->m_len1 + 1;

N2 =

->m_len2 + 1;

vector<TScore> stl_rowV (N2), stl_rowF(N2);

bFreeGapLeft1 =

->m_esf_L1 &&

->m_offset1 == 0;

bFreeGapRight1 =

->m_esf_R1 &&

bFreeGapLeft2 =

->m_esf_L2 &&

->m_offset2 == 0;

bFreeGapRight2 =

->m_esf_R2 &&

backtrace_matrix.

(0, 0);

stl_rowV[0] = wgleft1;

(k = 1; k < N2; ++k) {

stl_rowV[k] = stl_rowV[k-1] + wsleft1;

stl_rowF[k] = kInfMinus;

backtrace_matrix.

(k);

* seq1 =

+

->m_offset1;

* seq1_end = seq1 +

->m_len1;

(; seq1 != seq1_end && !

; ++seq1) {

( seq1 + 1 == seq1_end && bFreeGapRight1) {

tracer;

* row_sc = sm[(size_t)*seq1];

* seq2 =

+

->m_offset2;

* seq2_end = seq2 +

->m_len2;

* rowV = &stl_rowV[0];

* rowF = &stl_rowF[0];

(; seq2 != seq2_end;) {

= *rowV + row_sc[(size_t)*seq2++];

( bFreeGapRight2 && seq2 == seq2_end ) {

backtrace_matrix.

(++k, tracer);

backtrace_matrix.

(++k);

(

->m_transcript.rbegin(),

->m_transcript.rend(), rv.begin());

);

);

&id2,

trim_end_gaps)

(scope, loc1, loc2, trim_end_gaps);

&loc2,

trim_end_gaps)

);

vec1.GetSeqData(0, vec1.size(), seq1);

vec2.GetSeqData(0, vec2.size(), seq2);

);

);

guides_dim =

.size() / 4;

vector<SAlignInOut> TDataVector;

vector<size_t> seed_dims;

vdata.reserve(guides_dim + 1);

seed_dims.reserve(guides_dim + 1);

(

istart = 4*guides_dim,

= istart;

!= 0;

-= 4) {

dim_query = q1 - q0, dim_subj = s1 - s0;

esf_L1 =

, esf_R1 =

,

esf_L2 =

, esf_R2 =

;

s0, dim_subj, esf_L2, esf_R2);

vdata.push_back(

);

vdata.push_back(

);

vector<SAlignInOut*> TDataPtrVector;

TDataPtrVector vdata_p (vdata.size());

TDataPtrVector::iterator jj = vdata_p.begin();

stable_sort(vdata_p.begin(), vdata_p.end(),

idim = vdata.size();

vector<CNWAlignerThread_Align*> TThreadVector;

TThreadVector threads;

threads.reserve(idim);

(TDataPtrVector, ii, vdata_p) {

(

(

.GetSpace()) >= 10000000 &&

threads.push_back(thread);

unique_ptr<CException> e;

(TThreadVector, ii, threads) {

(*ii)->Join(

**

(&pe));

(

idata = 0; idata < idim; ++idata) {

(

.m_transcript.begin(),

.m_transcript.end(),

(idata + 1 < idim) {

(

k = 0; k < seed_dims[idata]; ++k) {

guides_dim =

.size() / 4;

(

istart = 4*guides_dim,

= istart;

!= 0;

-= 4) {

dim_query = q1 - q0, dim_subj = s1 - s0;

esf_L1 =

, esf_R1 =

,

esf_L2 =

, esf_R2 =

;

s0, dim_subj, esf_L2, esf_R2);

(

.m_transcript.begin(),

.m_transcript.end(),

(

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

(

.m_transcript.begin(),

.m_transcript.end(),

(std::bad_alloc&) {

c1 =

[i1];

c2 =

[i2];

N1 (

->m_len1 + 1);

N2 (

->m_len2 + 1);

->m_transcript.clear();

->m_transcript.reserve(N1 + N2);

k (N1*N2 - 1);

i1 (

->m_offset1 +

->m_len1 - 1);

i2 (

->m_offset2 +

->m_len2 - 1);

Key (backtrace[k]);

(k > 0 && (Key &

)) {

Key = backtrace[k--];

(k > 0 && (Key &

)) {

N1 (

->m_len1 + 1);

N2 (

->m_len2 + 1);

->m_transcript.clear();

->m_transcript.reserve(N1 + N2);

k (N1*N2 - 1);

i1 (

->m_offset1 +

->m_len1 - 1);

i2 (

->m_offset2 +

->m_len2 - 1);

sw_k = backtrace.

();

->FillEdgeGaps(k - sw_k,

);

i1 -= (k - sw_k) / (

->m_len2+1);

i2 -= (k - sw_k) % (

->m_len2+1);

Key (backtrace[k]);

score -= sm[(size_t)(

[i1])][(size_t)(

[i2])];

(k > 0 && (Key &

)) {

Key = backtrace[k--];

(k > 0 && (Key &

)) {

);

->FillEdgeGaps(k,

);

dim = guides.size();

* err = 0;

(

= 0;

< dim;

+= 4) {

( guides[

] > guides[

+1] || guides[

+2] > guides[

+3] ) {

err =

;

(guides[

] <= guides[

-3] || guides[

+2] <= guides[

-2]){

err =

;

dim1 = guides[

+ 1] - guides[

];

dim2 = guides[

+ 3] - guides[

+ 2];

err =

;

err =

;

err =

;

i1 (0), i2 (0),

(0);

(

k (dim - 1); k >= 0; --k) {

(

< s.size()) {

= g_nwaligner_nucleotides;

dim = strlen(

);

vector<TNCBIScore> iupacna (dim*dim,

);

iupacna[0] = iupacna[dim+1] = iupacna[2*(dim+1)] =

iupacna[3*(dim+1)] =

;

iupacna_psm.

= g_nwaligner_nucleotides;

iupacna_psm.

= &iupacna.front();

memset(Flags, 0,

Flags);

abc_size = strlen(

);

(k = 0; k < abc_size; ++k) {

Flags[unsigned(

((

)

[k]))] = 1;

Flags[unsigned(

((

)

[k]))] = 1;

Flags[unsigned(k)] = 1;

(k = 0; k <

; ++k) {

(Flags[

(seq[k])] == 0)

gdim (

.size());

mem = double(dim1) * dim2 * elem_size;

(

(4);

< gdim;

+= 4) {

mem = double(dim1) * dim2 * elem_size;

mem = double(dim1) * dim2 * elem_size;

start1,

start2)

dim (transcript.size());

* p1 (

+ start1);

* p2 (

+ start2);

(;

<dim; ++

) {

(

endi = dim; endi-- > 0; ) {

(;

< dim; ++

) {

c1 = *p1;

c2 = *p2;

score += sm[c1][c2];

state1 = state2 = 0;

(state1 != 1) score +=

;

state1 = 1; state2 = 0;

(state2 != 1) score +=

;

state1 = 0; state2 = 1;

(

= 0;

< dim; ++

) {

(transcript[

] ==

) ++

;

;

(

= 0;

< dim; ++

) {

(transcript[

] ==

) ++

;

;

(

= dim - 1;

>= 0; --

) {

(transcript[

] ==

) ++

;

;

(

= dim - 1;

>= 0; --

) {

(transcript[

] ==

) ++

;

;

* s0,

* s1,

min_size)

cur = 0, maxseg = 0;

* p1 =

;

* p2 =

;

i0 = 0, j0 = 0, imax = i0, jmax = j0;

(

k = trdim - 1; k >= 0; --k) {

(maxseg >= min_size)

ret_point;

(maxseg >= min_size)

ret_point;

(maxseg >= min_size)

ret_point;

*q0 = imax; *s0 = jmax;

*q1 = *q0 + maxseg - 1;

*s1 = *s0 + maxseg - 1;

(i1),

(i2),

(fp0) {}

(i1),

(i2),

(i3),

(i4) {}

* beg,

* end,

& err_index)

= 0,

;

(

* p = beg; p < end; ++p) {

:

= 0;

;

:

= 0x01;

;

:

= 0x02;

;

:

= 0x03;

;

: err_index = p - beg;

0x40;

* beg,

* end,

fingerprint,

,

(beg +

> end) {

* p0 = beg;

err_idx = 0; --p0;

= 0x40;

(

== 0x40 && p0 < end) {

;

(

!= fingerprint && ++p0 < end) {

(*(p0 +

- 1)) {

:

= 0;

;

:

= 0x01;

;

:

= 0x02;

;

:

= 0x03;

;

: err_index = p0 +

- 1 - beg;

guide_core)

(guide_core > guide_size) {

vector<nwaln_mrnaseg> segs;

(

= 0;

+ guide_size <=

; ) {

* beg =

+

;

* end =

+

+ guide_size;

vector<nwaln_mrnaguide> guides;

* beg =

+ idx;

(

= 0, seg_count = segs.size();

beg + guide_size <= end &&

< seg_count; ++

) {

* beg0 = beg;

( p == 0 && beg + guide_size <= end ) {

guide_size, err_idx );

* seq1 =

+ segs[

].a;

* seq2 = p;

(k = 0; k < guide_size; ++k) {

(seq1[k] != seq2[k])

;

(k == guide_size) {

i1 = segs[

].a;

i2 = segs[

].b;

i3 = seq2 -

;

i4 = i3 + guide_size - 1;

guides_dim = guides.size();

( guides_dim == 0 ||

i1 - 1 > guides[guides_dim - 1].q1 ||

i3 - 1 > guides[guides_dim - 1].s1 ) {

guides[guides_dim - 1].q1 = i2;

guides[guides_dim - 1].s1 = i4;

beg0 = p + guide_size;

guides_dim = guides.size();

offs = guide_core/2 - 1;

(

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

q0 = (guides[k].q0 + guides[k].q1) / 2;

s0 = (guides[k].s0 + guides[k].s1) / 2;

* s0,

* s1,

min_size)

cur = 0, maxseg = 0;

* p1 = seq1_end - 1;

* p2 = seq2_end - 1;

imax = i0, jmax = j0;

(

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

(maxseg >= min_size)

ret_point;

(maxseg >= min_size)

ret_point;

(maxseg >= min_size)

ret_point;

*q1 = imax; *s1 = jmax;

*q0 = imax - maxseg + 1;

*s0 = jmax - maxseg + 1;

* s0,

* s1)

cur = 0, maxseg = 0;

* p1 =

;

* p2 =

;

i0 = 0, j0 = 0, imax = i0, jmax = j0;

(

k = trdim-1; k >= 0; --k) {

*q0 = imax; *s0 = jmax;

*q1 = *q0 + maxseg - 1;

*s1 = *s0 + maxseg - 1;

trim_end_gaps)

(trim_end_gaps) {

fmt.AsDenseSeg(query_start, query_strand,

subj_start, subj_strand,

);

trim_end_gaps)

(trim_end_gaps) {

fmt.SetSeqIds(id0, id1);

fmt.AsDenseSeg(query_start, query_strand,

subj_start, subj_strand,

);

@ eExtreme_Biological

5' and 3'

CNcbiOstrstreamToString class helps convert CNcbiOstrstream to a string Sample usage:

static unsigned int GetCpuCount(void)

Return number of active CPUs/cores (never less than 1).

void SetBestPos(size_t k)

size_t MakePattern(const size_t hit_size=100, const size_t core_size=28)

size_t GetRightSeg(size_t *q0, size_t *q1, size_t *s0, size_t *s1, size_t min_size) const

void SetAt(size_t i, Uint1 v)

virtual bool x_CheckMemoryLimit(void)

void SetProgressCallback(FProgressCallback prg_callback, void *data)

virtual TScore x_Align(SAlignInOut *data)

virtual TScore ScoreFromTranscript(const TTranscript &transcript, size_t start1=kMax_UInt, size_t start2=kMax_UInt) const

virtual ETranscriptSymbol x_GetDiagTS(size_t i1, size_t i2) const

EGapPreference GetGapPreference() const

vector< size_t > m_guides

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

friend class CNWAlignerThread_Align

TTranscript GetTranscript(bool reversed=true) const

SNCBIFullScoreMatrix m_ScoreMatrix

const char * x_FindFingerPrint64(const char *beg, const char *end, unsigned char fingerprint, size_t size, size_t &err_index)

bool IsSmithWaterman() const

void SetBestScore(TNCBIScore score)

unsigned char x_CalcFingerPrint64(const char *beg, const char *end, size_t &err_index)

TScore GetScore(void) const

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

size_t x_CheckSequence(const char *seq, size_t len) const

bool m_ScoreMatrixInvalid

FProgressCallback m_prg_callback

string GetTranscriptString(void) const

void x_SWDoBackTrace(const CBacktraceMatrix4 &backtrace, SAlignInOut *data)

TNCBIScore BestScore() const

virtual TScore x_Run(void)

void EnableMultipleThreads(bool enable=true)

vector< ETranscriptSymbol > TTranscript

void SetSmithWaterman(bool SW)

bool m_PositivesAsMatches

void GetEndSpaceFree(bool *L1, bool *R1, bool *L2, bool *R2) const

void SetTranscript(const TTranscript &transcript)

void SetScoreMatrix(const SNCBIPackedScoreMatrix *scoremat)

EGapPreference m_GapPreference

void SetWms(TScore value)

CRef< objects::CDense_seg > GetDense_seg(TSeqPos query_start, objects::ENa_strand query_strand, TSeqPos subj_start, objects::ENa_strand subj_strand, bool trim_end_gaps=false) const

virtual size_t GetElemSize(void) const

size_t GetLeftSeg(size_t *q0, size_t *q1, size_t *s0, size_t *s1, size_t min_size) const

void SetPattern(const vector< size_t > &pattern)

void x_DoBackTrace(const CBacktraceMatrix4 &backtrace, SAlignInOut *data)

void SetGapPreference(EGapPreference p)

Control preference for where to place a gap if there is a choice; default is eLater,...

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

static bool PSpace(const SAlignInOut *p1, const SAlignInOut *p2)

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 NCBI_THROW(exception_class, err_code, message)

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

ENa_strand GetStrand(void) const

Get the location's strand.

TSeqPos GetStart(ESeqLocExtremes ext) const

Return start and stop positions of the seq-loc.

const CSeq_id * GetId(void) const

Get the id of the location return NULL if has multiple ids or no id at all.

@ eCoding_Iupac

Set coding to printable coding (Iupacna or Iupacaa)

int64_t Int8

8-byte (64-bit) signed integer

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

bool Run(TRunMode flags=fRunDefault)

Run the thread.

@ eType_partial

mapping pieces together

ENa_strand

strand of nucleic acid

bool IsWhole(void) const

Check if variant Whole is selected.

bool IsInt(void) const

Check if variant Int is selected.

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

#define F(x)

Make a parametrized function appear to have only one variable.

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

const unsigned char kMaskFc

const unsigned char kMaskEc

const unsigned char kMaskE

const unsigned char kMaskD

bool NW_RequestNewThread(const unsigned int max_threads)

#define NCBI_FSM_DIM

Recommended approach: unpack and index directly.

void NCBISM_Unpack(const SNCBIPackedScoreMatrix *psm, SNCBIFullScoreMatrix *fsm)

Expand a packed score matrix into an unpacked one, which callers can proceed to index directly by sta...

int TNCBIScore

data types

const char g_msg_InconsistentArguments[]

const char g_msg_HitSpaceLimit[]

const char g_msg_InvalidTranscriptSymbol[]

const char g_msg_NoAlignment[]

const char g_msg_OutOfSpace[]

const char g_msg_NullParameter[]

const char g_msg_DataNotAvailable[]

const TNCBIScore * scores

strlen(symbols) x strlen(symbols)

TNCBIScore defscore

score for unknown residues

const char * symbols

order of residues

nwaln_mrnaguide(size_t i1, size_t i2, size_t i3, size_t i4)

naive pattern generator (a la Rabin-Karp)

nwaln_mrnaseg(size_t i1, size_t i2, unsigned char fp0)

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