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

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

NCBI C++ ToolKit: src/algo/blast/dbindex_search/sr_search_impl.hpp Source File

template< typename index_t >

index_impl_( dynamic_cast<

& >(*index) )

TIndex::TOffsetIterator

;

idx,

fw_strand,

& res_cache, vector< TIter > & single_res_cache,

vector< TSeqPos > & positions );

vector< TSeqPos > & positions,

vector< TIter > & cache,

vector< Uint1 > & cache_set );

searchOneMismatch(

vector< TSeqPos > & positions,

vector< TIter > & scache,

vector< Uint1 > & scache_set,

vector< TIter > single_res_cache[2];

vector< Uint1 > single_res_cache_set[2];

vector< TIter > scache1[2];

vector< TIter > scache2[2];

vector< Uint1 > scache_set1[2];

vector< Uint1 > scache_set2[2];

<

index_t >

vector< TIter > & single_res_cache,

vector< TSeqPos > & positions )

res_cache.

( idx, fw_strand );

( idx != single_res_cache.size() ) {

(

= 0;

< single_res_cache.size(); ++

)

pos = positions[

];

& s = single_res_cache[

];

(

.empty() ) copyOffsets(

, s );

p = (idx == 0) ? pos - hkey_width_ : pos;

mergeOffsets(

, s, p );

(

.empty() )

;

{

.clear();

; }

(

= 0, pos = 0;

< single_res_cache.size() - 2; ++

, pos += hkey_width_ ) {

& s = single_res_cache[

];

(

.empty() ) copyOffsets(

, s );

mergeOffsets(

, s, pos );

(

.empty() )

;

{

.clear();

; }

<

index_t >

index_impl_.getLOff(

) };

<

index_t >

( TSRResults::iterator ires =

.begin();

ires !=

.end(); ++ires ) {

offres.

= index_impl_.getLId( o );

offres.

= index_impl_.getLOff( o );

( offres.

> ires->seqnum ||

( offres.

== ires->seqnum &&

offres.

>= ires->soff + step ) )

( !

.Advance() )

;

( offres.

== ires->seqnum &&

offres.

== ires->soff + step )

<

index_t >

vector< TSeqPos > & positions,

vector< TIter > & cache, vector< Uint1 > & cache_set )

(

)

;

cache_set[cache_idx] =

;

= index_impl_.OffsetIterator(

, hkey_width_ );

( (++

) != positions.size() ) {

pos = positions[

];

= getNMer( seq, pos, fw_strand,

);

(

)

;

= index_impl_.OffsetIterator(

, hkey_width_ );

cache_set[cache_idx] =

;

(

.end() ) max_pos = pos + hkey_width_;

max_pos = hkey_width_;

<

index_t >

& seq,

vector< TSeqPos > & positions,

vector< TIter > & scache,

vector< Uint1 > & scache_set,

results_info.

();

letters[4] = {

,

,

,

};

(

= 0;

< positions.size(); ++

)

( !scache_set[

] ) {

(

)

;

scache[

] = index_impl_.OffsetIterator(

, hkey_width_ );

pair< TSeqPos, TSeqPos > range =

Pos2Index(

, seq.

(), mismatch_info );

( !cache.

( mismatch_info.

, fw_strand ) ) {

mismatch_info.

, fw_strand,

cache, scache, positions );

(

.empty() ) {

= range.second;

; }

(

= range.first;

< range.second; ++

) {

orig_letter = seq[p];

(

j = 0; j < 4; ++j )

( letters[j] != orig_letter ) {

subst_letter = letters[j];

seq, mismatch_info.

[0],

fw_strand,

,

, subst_letter );

(

)

;

index_impl_.OffsetIterator(

, hkey_width_ );

r_entry.

(

, subst_letter, mismatch_info.

[0] );

( mismatch_info.

== 2 ) {

seq, mismatch_info.

[1],

fw_strand,

,

, subst_letter );

(

)

;

index_impl_.OffsetIterator(

( mismatch_info.

== 0 )

mergeResults(

,

, hkey_width_ );

<

index_t >

paired = (sdata.

!= 0);

vector< TSeqPos > positions1 = GetQNmerPositions( sz1 );

vector< TSeqPos > positions2 = GetQNmerPositions( sz2 );

( positions1.empty() || positions2.empty() )

;

maxpos1[2] = { sz1, sz1 };

maxpos2[2] = { sz2, sz2 };

(

strand = 0; strand < 2; ++strand ) {

scache1[strand].clear();

scache_set1[strand].clear();

scache1[strand].resize( positions1.size() );

scache_set1[strand].resize( positions1.size(), 0 );

hk_data_.exact_1[strand].clear();

seq1, positions1, strand,

hk_data_.exact_1[strand], maxpos1[strand],

scache1[strand], scache_set1[strand] );

scache2[strand].clear();

scache_set2[strand].clear();

scache2[strand].resize( positions2.size() );

scache_set2[strand].resize( positions2.size(), 0 );

hk_data_.exact_2[strand].clear();

seq2, positions2, strand,

hk_data_.exact_2[strand], maxpos2[strand],

scache2[strand], scache_set2[strand] );

(

)

;

matches_found =

;

( !hk_data_.exact_1[

].empty() )

(

j = 0; j < 2; ++j )

( !hk_data_.exact_2[j].empty() ) {

hk_data_.exact_1[

], hk_data_.exact_2[j],

matches_found =

;

& mismatch = sdata.

;

( mismatch && !matches_found ) {

matches_found =

;

res_cache1.

( positions1.size() + 1 );

res_cache2.

( positions2.size() + 1 );

(

strand = 0; strand < 2; ++strand ) {

= searchOneMismatch(

seq1, positions1, maxpos1[strand], strand,

hk_data_.mm_1[strand],

scache1[strand], scache_set1[strand],

= searchOneMismatch(

seq2, positions2, maxpos2[strand], strand,

hk_data_.mm_2[strand],

scache2[strand], scache_set2[strand],

(

)

;

( !hk_data_.exact_1[

].empty() ) {

(

j = 0; j < 2; ++j ) {

( !hk_data_.mm_2[j].empty() ) {

(

ind = 0; ind < hk_data_.mm_2[j].size(); ++ind ) {

hk_data_.exact_1[

], it.

,

matches_found =

;

( !hk_data_.mm_1[

].empty() ) {

(

j = 0; j < 2; ++j ) {

( !hk_data_.exact_2[j].empty() ) {

(

ind = 0; ind < hk_data_.mm_1[

].size(); ++ind ) {

it.

, hk_data_.exact_2[j],

matches_found =

;

( !hk_data_.mm_2[j].empty() ) {

(

iind = 0; iind < hk_data_.mm_1[

].size(); ++iind ) {

(

jind = 0; jind < hk_data_.mm_2[j].size(); ++jind ) {

matches_found =

;

( !matches_found ) {

matches_found =

;

( !hk_data_.exact_1[

].empty() ) {

matches_found =

;

sz1, hk_data_.exact_1[

],

,

, 0, (

)

, 0, 1 ) ) {

( !matches_found ) {

( !hk_data_.mm_1[

].empty() ) {

matches_found =

;

(

ind = 0; ind < hk_data_.mm_1[

].size(); ++ind ) {

( !matches_found ) outres.

= EM;

matches_found =

;

+= outres.

.size();

( !hk_data_.exact_2[

].empty() ) {

sz2, hk_data_.exact_2[

],

,

, 0, (

)

, 0, 2 ) ) {

matches_found =

;

( !matches_found ) {

+= outres.

.size();

( !hk_data_.mm_2[

].empty() )

(

ind = 0; ind < hk_data_.mm_2[

].size(); ++ind ) {

& mismatch = sdata.

;

vector< TSeqPos > positions = GetQNmerPositions( sz );

exact_matches_found =

;

max_mismatch_pos[2] = { sz, sz };

( !positions.empty() ) {

fw_strand =

;

res_cache.

( positions.size() + 1 );

single_res_cache[fw_strand].clear();

single_res_cache_set[fw_strand].clear();

single_res_cache[fw_strand].resize( positions.size() );

single_res_cache_set[fw_strand].resize(

positions.size(),

);

seq, positions, fw_strand,

,

max_mismatch_pos[fw_strand],

single_res_cache[fw_strand],

single_res_cache_set[fw_strand] );

( reportResults( outres,

, sz,

, fw_strand ) ) {

fw_strand = !fw_strand;

( !

.empty() ) exact_matches_found =

;

}

( !fw_strand );

(

)

;

( mismatch && !exact_matches_found ) {

fw_strand =

;

fw_strand = !fw_strand;

= searchOneMismatch(

max_mismatch_pos[fw_strand], fw_strand,

single_res_cache[fw_strand],

single_res_cache_set[fw_strand],

(

ind = 0; ind < results_info.size(); ++ind ) {

sz, it.

, fw_strand, mismatch,

}

( !fw_strand );

(

)

;

TSRResults & at(Uint4 idx, bool fw_strand)

bool is_set(Uint4 idx, bool fw_strand) const

void set(Uint4 idx, bool fw_strand)

bool searchOneMismatch(const CSeqVector &seq, const vector< TSeqPos > &positions, Uint4 max_pos, bool fw_strand, CMismatchResultsInfo &results_info, vector< TIter > &scache, const vector< Uint1 > &scache_set, CResCache &cache)

void mergeOffsets(TSRResults &resutls, TIter &offsets, Uint4 step)

CSRSearch_Impl(CRef< CDbIndex > index, TSeqPos d, TSeqPos dfuzz)

void copyOffsets(TSRResults &resutls, TIter &offsets)

virtual void search(const SSearchData &sdata, TResults &results)

bool searchExact(const CSeqVector &seq, const vector< TSeqPos > &positions, bool fw_strand, TSRResults &results, TSeqPos &max_pos, vector< TIter > &cache, vector< Uint1 > &cache_set)

TIndex::TOffsetIterator TIter

void setResults4Idx(Uint4 idx, bool fw_strand, CResCache &res_cache, vector< TIter > &single_res_cache, const vector< TSeqPos > &positions)

vector< SSRResult > TSRResults

vector< TSRPairedResult > TSRPairedResults

unsigned int TSeqPos

Type for sequence locations and lengths.

uint8_t Uint1

1-byte (8-bit) unsigned 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.

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

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

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

static PCRE2_SIZE * offsets

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)

USING_SCOPE(ncbi::objects)

void init(TSeqPos pos, Uint4 letter, Uint1 adj)

TSeqPos mismatch_position

vector< SResultData > res

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