A RetroSearch Logo

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

Search Query:

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

NCBI C++ ToolKit: src/algo/blast/dbindex_search/sr_search.cpp Source File

49  if

( index->isLegacy() ) {

91  for

( ; pos < end ; ++pos ) {

95  case 'A'

:

case 'a'

:

letter

= 0;

break

;

96  case 'C'

:

case 'c'

:

letter

= 1;

break

;

97  case 'G'

:

case 'g'

:

letter

= 2;

break

;

98  case 'T'

:

case 't'

:

letter

= 3;

break

;

109  for

( ; pos < end ; ++pos ) {

112  switch

( seq[

l

- pos - 1] ) {

113  case 'A'

:

case 'a'

:

letter

= 3;

break

;

114  case 'C'

:

case 'c'

:

letter

= 2;

break

;

115  case 'G'

:

case 'g'

:

letter

= 1;

break

;

116  case 'T'

:

case 't'

:

letter

= 0;

break

;

138  for

( ; pos < end ; ++pos ) {

141  if

( pos == sub_pos ) {

142  switch

( sub_letter ) {

143  case 'A'

:

case 'a'

:

letter

= 0;

break

;

144  case 'C'

:

case 'c'

:

letter

= 1;

break

;

145  case 'G'

:

case 'g'

:

letter

= 2;

break

;

146  case 'T'

:

case 't'

:

letter

= 3;

break

;

151  switch

( seq[pos] ) {

152  case 'A'

:

case 'a'

:

letter

= 0;

break

;

153  case 'C'

:

case 'c'

:

letter

= 1;

break

;

154  case 'G'

:

case 'g'

:

letter

= 2;

break

;

155  case 'T'

:

case 't'

:

letter

= 3;

break

;

167  for

( ; pos < end ; ++pos ) {

170  if

( sub_pos == pos ) {

171  switch

( sub_letter ) {

172  case 'A'

:

case 'a'

:

letter

= 3;

break

;

173  case 'C'

:

case 'c'

:

letter

= 2;

break

;

174  case 'G'

:

case 'g'

:

letter

= 1;

break

;

175  case 'T'

:

case 't'

:

letter

= 0;

break

;

180  switch

( seq[

l

- pos - 1] ) {

181  case 'A'

:

case 'a'

:

letter

= 3;

break

;

182  case 'C'

:

case 'c'

:

letter

= 2;

break

;

183  case 'G'

:

case 'g'

:

letter

= 1;

break

;

184  case 'T'

:

case 't'

:

letter

= 0;

break

;

200

pair< TSeqPos, TSeqPos >

result

;

206

mismatch_info.

idx

= div;

214

mismatch_info.

idx

= div;

221

mismatch_info.

idx

= div;

244  if

( src.size() > 0 ) {

246

TSRResults::const_iterator isrc = src.begin();

248  for

( TSRResults::iterator ires =

results

.begin();

249

ires !=

results

.end(); ++ires ) {

250  if

( ires->soff <

test

)

continue

;

251  while

( isrc != src.end() ) {

252  if

( isrc->seqnum > ires->seqnum ||

253

( isrc->seqnum == ires->seqnum &&

254

isrc->soff >= ires->soff + step ) )

260  if

( isrc == src.end() )

break

;

262  if

( isrc->seqnum == ires->seqnum &&

263

isrc->soff == ires->soff + step )

280

TSRResults::const_iterator

i

= results_1.begin();

281

TSRResults::const_iterator j = results_2.begin();

283  while

(

i

!= results_1.end() && j != results_2.end() ) {

284  if

(

i

->seqnum < j->seqnum ) {

285  if

(

i

->seqnum + 1 == j->seqnum ) {

290

TSRResults::const_iterator k = j;

295  if

( s < chunk_overlap +

dmax_

) {

296  if

( s >= chunk_overlap +

dmin_

) {

297  results

.push_back( make_pair( *

i

, *k ) );

300  if

( ++k == results_2.end() ||

301

k->seqnum != j->seqnum )

311  else if

(

i

->seqnum > j->seqnum ) {

312  if

(

i

->seqnum == j->seqnum + 1 ) {

317

TSRResults::const_iterator k =

i

;

322  if

( s < chunk_overlap +

dmax_

) {

323  if

( s >= chunk_overlap +

dmin_

) {

324  results

.push_back( make_pair( *k, *j ) );

327  if

( ++k == results_1.end() ||

328

k->seqnum !=

i

->seqnum )

339  TSeqPos

jsoff = j->soff + adjust;

341  while

(

i

!= results_1.end() &&

342  i

->seqnum == j->seqnum &&

343  i

->soff +

dmax_

< jsoff )

346  if

(

i

== results_1.end() ||

i

->seqnum != j->seqnum )

continue

;

347

TSRResults::const_iterator k =

i

;

349  while

( k != results_1.end() &&

350

k->seqnum == j->seqnum &&

351

k->soff +

dmin_

<= jsoff ) {

352  results

.push_back( make_pair( *k, *j ) );

356  if

( k == results_1.end() || k->seqnum != j->seqnum )

359  while

( k != results_1.end() &&

360

k->seqnum == j->seqnum &&

361

k->soff < jsoff +

dmin_

)

364  if

( k == results_1.end() || k->seqnum != j->seqnum )

367  while

( k != results_1.end() &&

368

k->seqnum == j->seqnum &&

369

k->soff <= jsoff +

dmax_

) {

370  results

.push_back( make_pair( *k, *j ) );

384

pair< TSeqNum, TSeqPos > sd =

388  if

( cd.second + sz <= index_->getChunkOverlap() &&

406  if

( outres.

res

.size() ==

nr

)

return true

;

408  if

( mismatch ) mismatch_pos += 1;

410  for

( TSRResults::const_iterator cires =

results

.begin();

411

cires !=

results

.end(); ++cires ) {

414

pair< TSeqNum, TSeqPos > m =

415  MapSOff

( cires->seqnum, soff, qsz, overlap );

416  if

( overlap )

continue

;

417  Uint4

subj = m.first;

419

subj, 1 + m.second, fw, mismatch_pos,

420

mismatch_letter, pos_in_pair );

421

outres.

res

.push_back(

r

);

422  if

( outres.

res

.size() ==

nr

)

return true

;

432  bool

fw1,

bool

fw2,

bool

mismatch1,

bool

mismatch2,

434  Uint1

mismatch_letter1,

Uint1

mismatch_letter2,

437  if

( outres.

res

.size() ==

nr

)

return true

;

439  if

( mismatch1 ) mismatch_pos1 += 1;

440  if

( mismatch2 ) mismatch_pos2 += 1;

442  for

( TSRPairedResults::const_iterator cires =

results

.begin();

443

cires !=

results

.end(); ++cires ) {

448  bool

overlap1, overlap2;

449

pair< TSeqNum, TSeqPos > m1 =

450  MapSOff

(

r1

.seqnum, soff1, qsz1, overlap1 );

451

pair< TSeqNum, TSeqPos > m2 =

452  MapSOff

(

r2

.seqnum, soff2, qsz2, overlap2 );

453  if

( overlap1 || overlap2 )

continue

;

455  if

( m1.first == m2.first ) {

459

1 + m1.second, 1 + m2.second,

460

fw1, fw2, mismatch_pos1, mismatch_pos2,

461

mismatch_letter1, mismatch_letter2 );

462

outres.

res

.push_back(

r

);

463  if

( outres.

res

.size() ==

nr

)

return true

;

474  case eAmbig

:

return "ambiguous base in the query"

;

Implementation of the BLAST database index.

Base class providing high level interface to index objects.

pair< TSeqNum, TSeqPos > getSIdOffByCIdOff(TSeqNum cid, TSeqPos coff) const

pair< TSeqNum, TSeqPos > getCIdOffByLIdOff(TSeqNum lid, TSeqPos loff) const

unsigned long getChunkOverlap() const

unsigned long getMaxChunkSize() const

TSeqNum getSIdByCId(TSeqNum cid) const

pair< TSeqNum, TSeqPos > getSIdOffByLIdOff(TSeqNum lid, TSeqPos loff) const

TSeqNum getOIdBySId(TSeqNum sid) const

virtual const char * GetErrCodeString() const

Get error code interpreted as text.

void mergeResults(TSRResults &results, const TSRResults &src, Int4 step)

vector< SSRResult > TSRResults

bool reportResults(TResults &r, Uint4 nr, TSeqPos qsz1, TSeqPos qsz2, const TSRPairedResults &results, bool fw1, bool fw2, bool mismatch1=false, bool mismatch2=false, TSeqPos mismatch_pos1=0, TSeqPos mismatch_pos2=0, Uint1 mismatch_letter1=(Uint1)'-', Uint1 mismatch_letter2=(Uint1)'-', Uint4 adjustment1=0, Uint4 adjustment2=0)

pair< TSeqNum, TSeqPos > MapSOff(TSeqNum lid, TSeqPos loff, TSeqPos sz, bool &overlap) const

Uint4 getNMer(const CSeqVector &seq, TSeqPos pos, bool fw, bool &ambig) const

vector< TSRPairedResult > TSRPairedResults

CDbIndex::TSeqNum TSeqNum

unsigned long hkey_width_

vector< TSeqPos > GetQNmerPositions(TSeqPos sz) const

pair< TSeqPos, TSeqPos > Pos2Index(TSeqPos pos, TSeqPos sz, SMismatchInfo &mismatch_info) const

void combine(const TSRResults &results_1, const TSRResults &results_2, TSRPairedResults &results, Int4 adjust=0)

static const int chunk_size

#define test(a, b, c, d, e)

unsigned int TSeqPos

Type for sequence locations and lengths.

TErrCode GetErrCode(void) const

Get error code.

virtual const char * GetErrCodeString(void) const

Get error code interpreted as text.

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

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

#define BEGIN_SCOPE(ns)

Define a new scope.

Magic spell ;-) needed for some weird compilers... very empiric.

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

static const sljit_gpr r1

static SLJIT_INLINE sljit_ins nr(sljit_gpr dst, sljit_gpr src)

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

static const sljit_gpr r2

USING_SCOPE(ncbi::objects)

vector< SResultData > res

static Uint4 letter(char c)

static bool ambig(char c)

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