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

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

NCBI C++ ToolKit: src/algo/seqqa/single_aln_tests.cpp Source File

(aln->

() == ncbi::CSeq_align::eType_disc) {

(neighborhood > 0 && pos > 0 && pos < bsh.

() - 1) {

loc->

().SetFrom(pos);

loc->

().SetTo(pos);

loc->

().SetStrand(strand);

loc->

().SetFrom(pos <

(neighborhood) ? 0 : pos -

(neighborhood));

(neighborhood < 0) {

reverse(seq.begin(), seq.end());

best_pos(

);

w_match = 1;

w_mismatch = -4;

x_dropoff = 15;

(

curr_pos = 0;

curr_pos < seq.size() && curr_score + x_dropoff > best_score;

curr_score += seq[curr_pos] ==

? w_match : w_mismatch;

(curr_score >= best_score) {

best_score = curr_score;

priming_length = best_pos ==

? 0 : best_pos + 1;

priming_length;

( !aln || !

) {

.AddField(

, (

) disc.size());

cds_from = 0, cds_to = 0;

& genomic_id = disc.front()->GetSeq_id(1);

xcript_prot, genomic_prot;

can_make_same_prot =

;

(xcript_prot == genomic_prot &&

xcript_prot.find_first_not_of(

) ==

) {

can_make_same_prot =

;

can_make_same_prot =

;

.AddField(

, can_make_same_prot);

aligned_residue_count = 0;

cds_aligned_residue_count = 0;

match_count = 0, possible_match_count = 0;

cds_match_count = 0, cds_possible_match_count = 0;

vector<int> cds_match_count_by_frame(3);

vector<int> cds_possible_match_count_by_frame(3);

consensus_cds_splices = 0;

min_exon_length = 0, max_exon_length = 0;

min_intron_length = 0, max_intron_length = 0;

exon_length, intron_length;

exon_match_count, exon_possible_match_count;

worst_exon_match_frac = 1.1;

worst_exon_match_count = 0;

worst_exon_possible_match_count = 0;

cds_indel_count = 0;

& genomic_seq = genomic_seq_data.

().

();

& genomic_cds_seq = genomic_cds_seq_data.

().

();

exon_length =

.GetLength();

(exon_index == 0) {

exon_length_5p = exon_length;

exon_length_3p = exon_length;

(exon_index == 0 || exon_length > max_exon_length) {

max_exon_length = exon_length;

(exon_index == 0 || exon_length < min_exon_length) {

min_exon_length = exon_length;

intron_length = last_genomic_end - exon.

(1)- 1;

intron_length = exon.

(1) - last_genomic_end - 1;

(exon_index > 0) {

(exon_index == 1 || intron_length > max_intron_length) {

max_intron_length = intron_length;

(exon_index == 1 || intron_length < min_intron_length) {

min_intron_length = intron_length;

loc.

().SetFrom(last_genomic_end - 2);

loc.

().SetTo (last_genomic_end - 1);

loc.

().SetFrom(last_genomic_end + 1);

loc.

().SetTo (last_genomic_end + 2);

(consensus_splice) {

(consensus_splice) {

++consensus_cds_splices;

.AddField(

, exon_index);

downstream_intron_count =

disc.size() - exon_index - 1;

.AddField(

,

(

) downstream_intron_count);

(downstream_intron_count > 0) {

.AddField(

,

.AddField(

,

((*++disc.rbegin())->GetSeqStop(0) - cds_to));

exon_match_count = 0;

exon_possible_match_count = 0;

in_cds = has_cds

gap_in_xcript = avec.

(0,

) ==

;

gap_in_genomic = avec.

(1,

) ==

;

(!gap_in_xcript) {

in_cds = pos >= cds_from && pos <= cds_to;

(!gap_in_genomic) {

++aligned_residue_count;

++cds_aligned_residue_count;

(cds_match_count == 0

&& cds_possible_match_count == 0) {

++cds_match_count_by_frame[frame];

}

(!gap_in_xcript) {

cdna_res =

genomic_res =

(!(cdna_res & ~genomic_res)) {

++exon_possible_match_count;

(cds_match_count == 0

&& cds_possible_match_count == 0) {

++cds_possible_match_count;

++cds_possible_match_count_by_frame[frame];

(gap_in_xcript && in_cds) {

(gap_in_genomic && in_cds) {

(!gap_in_genomic && in_cds) {

genomic_cds_seq.push_back(avec.

(1,

));

match_count += exon_match_count;

possible_match_count += exon_possible_match_count;

exon_match_frac =

double(exon_match_count + exon_possible_match_count) / exon_length;

(exon_match_frac < worst_exon_match_frac) {

worst_exon_match_frac = exon_match_frac;

worst_exon_match_count = exon_match_count;

worst_exon_possible_match_count = exon_possible_match_count;

worst_exon_length = exon_length;

(

seg = 0; seg < avec.

(); ++seg) {

(avec.

(0, seg) == -1) {

(avec.

(1, seg) == -1) {

exon_genomic_seq;

genomic_seq += exon_genomic_seq;

.AddField(

, (

) max_exon_length);

.AddField(

, (

) min_exon_length);

.AddField(

, (

) exon_length_5p);

.AddField(

, (

) exon_length_3p);

(disc.size() > 1) {

.AddField(

, (

) max_intron_length);

.AddField(

, (

) min_intron_length);

.AddField(

, (

) aligned_residue_count);

.AddField(

, (

) match_count);

.AddField(

, (

) possible_match_count);

.AddField(

, (

) cds_match_count);

.AddField(

,

(

) cds_possible_match_count);

.AddField(

, (

) cds_aligned_residue_count);

.AddField(

,

(

) cds_match_count_by_frame[0]);

.AddField(

,

(

) cds_possible_match_count_by_frame[0]);

.AddField(

, (

) total_splices);

.AddField(

, (

) consensus_splices);

.AddField(

,

(

) total_cds_splices);

.AddField(

,

(

) consensus_cds_splices);

.AddField(

,

(

) disc.front()->GetSeqStart(0));

.AddField(

,

- disc.back()->GetSeqStop(0) - 1));

.AddField(

,

disc.front()->GetSeqStart(0) <= cds_from);

.AddField(

,

disc.back()->GetSeqStop(0) >= cds_to);

.AddField(

,

(worst_exon_match_count));

.AddField(

,

(worst_exon_possible_match_count));

.AddField(

,

(worst_exon_length));

.AddField(

, indel_count);

.AddField(

, cds_indel_count);

vector<TSeqPos> out_indices;

.AddField(

,

(gac));

.AddField(

,

(gcac));

.AddField(

,

.AddField(

,

& first_exon = *disc.front();

genomic_earliest, genomic_latest;

.AddField(is_minus ?

:

,

(genomic_earliest) -

(

));

.AddField(is_minus ?

:

,

(

) -

(genomic_latest));

(disc.size() == 1) {

kLargestGeneDist = 10000;

genomic_roi_from = genomic_start + 1;

genomic_roi_from = genomic_start;

(genomic_start + kLargestGeneDist + 1

genomic_roi_to = genomic_start + kLargestGeneDist + 1;

(genomic_start > kLargestGeneDist) {

genomic_roi_from = genomic_start - kLargestGeneDist - 1;

genomic_roi_from = 0;

(genomic_start > 1) {

genomic_roi_to = genomic_start - 1;

shortest_dist = kLargestGeneDist + 1;

shortest_dist = genomic_start

.AddField(

,

shortest_dist <= kLargestGeneDist);

(shortest_dist <= kLargestGeneDist) {

.AddField(

,

(shortest_dist));

vector<TSignedSeqPos>

vector<TSignedSeqPos> rv;

rv.reserve(lens.size());

rv.push_back((end + 1) -

);

rv.push_back(start +

);

vector<TSeqPos> product_lens;

vector<TSeqPos> genomic_lens;

product_lens.push_back(part.

());

genomic_lens.push_back(part.

());

}

(part.

()) {

product_lens.push_back(part.

());

genomic_lens.push_back(part.

());

genomic_lens.push_back(0);

product_lens.push_back(0);

runtime_error(

);

lens.reserve(product_lens.size());

(

= 0;

< product_lens.size(); ++

) {

lens.push_back(

(product_lens[

], genomic_lens[

]));

vector<TSignedSeqPos> product_starts =

vector<TSignedSeqPos> genomic_starts =

starts.reserve(product_starts.size() + genomic_starts.size());

(

= 0;

< lens.size(); ++

) {

starts.push_back(product_starts[

]);

starts.push_back(genomic_starts[

]);

(

= 0;

< lens.size(); ++

) {

strands.push_back(product_strand);

strands.push_back(genomic_strand);

product_strand, genomic_strand,

product_id, genomic_id);

ds_align->

().SetDenseg(*ds);

disc->

().SetDisc().Set().push_back(ds_align);

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

bool IsReverse(ENa_strand s)

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.

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

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

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

TSeqPos GetAlnStop(TNumseg seg) const

TSeqPos GetSeqStop(TNumrow row) const

TSignedRange GetRange(TNumrow row, TNumseg seg, int offset=0) const

TNumseg GetNumSegs(void) const

TSeqPos GetSeqStart(TNumrow row) const

string & GetSeqString(string &buffer, TNumrow row, TSeqPos seq_from, TSeqPos seq_to) const

void SetEndChar(TResidue gap_char)

void SetGapChar(TResidue gap_char)

TResidue GetResidue(TNumrow row, TSeqPos aln_pos) const

static unsigned char FromIupac(unsigned char c)

void Compact()

Join adjacent mergeable segments to create a more compact alignment.

CSeqTestContext defines any contextual information that a derived class might need.

CRef< objects::CSeq_test_result > x_SkeletalTestResult(const string &test_name)

Create a Seq-test-result with some fields filled in, including a name for this test,...

CRange< TSeqPos > GetSeqRange(TDim row) const

GetSeqRange NB: On a Spliced-seg, in case the product-type is protein, these only return the amin par...

TSeqPos GetSeqStop(TDim row) const

const CSeq_id & GetSeq_id(TDim row) const

Get seq-id (the first one if segments have different ids).

TSeqPos GetSeqStart(TDim row) const

ENa_strand GetSeqStrand(TDim row) const

Get strand (the first one if segments have different strands).

CSeq_test_result_set –.

static TSeqPos GetAmbigs(const CSeq_data &in_seq, CSeq_data *out_seq, vector< TSeqPos > *out_indices, CSeq_data::E_Choice to_code=CSeq_data::e_Ncbi2na, TSeqPos uBeginIdx=0, TSeqPos uLength=0)

Base class for all serializable objects.

CRef< objects::CSeq_test_result_set > RunTest(const CSerialObject &obj, const CSeqTestContext *ctx)

RunTest() is called for each registered object.

bool CanTest(const CSerialObject &obj, const CSeqTestContext *ctx) const

Test to see whether the given object *can* be used in this test.

bool IsConsensusSplice(const string &splice5, const string &splice3)

Consensus splice is GY..AG or AT..AC.

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

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

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

C * SerialClone(const C &src)

Create on heap a clone of the source object.

TSeqPos GetStop(const CSeq_loc &loc, CScope *scope, ESeqLocExtremes ext=eExtreme_Positional)

If only one CBioseq is represented by CSeq_loc, returns the position at the stop of the location.

ENa_strand GetStrand(const CSeq_loc &loc, CScope *scope=0)

Returns eNa_strand_unknown if multiple Bioseqs in loc Returns eNa_strand_other if multiple strands in...

TSeqPos GetStart(const CSeq_loc &loc, CScope *scope, ESeqLocExtremes ext=eExtreme_Positional)

If only one CBioseq is represented by CSeq_loc, returns the position at the start of the location.

static void Translate(const string &seq, string &prot, const CGenetic_code *code, bool include_stop=true, bool remove_trailing_X=false, bool *alt_start=NULL, bool is_5prime_complete=true, bool is_3prime_complete=true)

Translate a string using a specified genetic code.

CRef< CSeq_loc > Map(const CSeq_loc &src_loc)

Map seq-loc.

CBioseq_Handle GetBioseqHandle(const CSeq_id &id)

Get bioseq handle by seq-id.

const CSeqFeatData & GetData(void) const

TSeqPos GetBioseqLength(void) const

TInst_Length GetInst_Length(void) const

const CSeqMap & GetSeqMap(void) const

Get sequence map.

CRef< CSeq_loc > GetRangeSeq_loc(TSeqPos start, TSeqPos stop, ENa_strand strand=eNa_strand_unknown) const

Return CSeq_loc referencing the given range and strand on the bioseq If start == 0,...

@ eCoding_Iupac

Set coding to printable coding (Iupacna or Iupacaa)

TSeqPos GetEndPosition(void) const

return end position of current segment in sequence (exclusive)

SAnnotSelector & SetResolveAll(void)

SetResolveAll() is equivalent to SetResolveMethod(eResolve_All).

const CSeq_loc & GetLocation(void) const

SAnnotSelector & SetResolveDepth(int depth)

SetResolveDepth sets the limit of subsegment resolution in searching annotations.

const CSeq_feat & GetMappedFeature(void) const

Feature mapped to the master sequence.

CSeqMap::ESegmentType GetType(void) const

TSeqPos GetPosition(void) const

return position of current segment in sequence

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

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

CSeqMap_CI Begin(CScope *scope) const

NCBI style methods.

void SetIupacCoding(void)

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

const_iterator begin(void) const

const_iterator end(void) const

void Reset(void)

Reset reference object.

bool IntersectingWith(const TThisType &r) const

#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.

void SetTo(TTo value)

Assign a value to To data member.

Tdata & Set(void)

Assign a value to data member.

const TDenseg & GetDenseg(void) const

Get the variant data.

TLens & SetLens(void)

Assign a value to Lens data member.

const TGenomic_id & GetGenomic_id(void) const

Get the Genomic_id member data.

TMatch GetMatch(void) const

Get the variant data.

const TProduct_id & GetProduct_id(void) const

Get the Product_id member data.

TGenomic_start GetGenomic_start(void) const

Get the Genomic_start member data.

bool IsMismatch(void) const

Check if variant Mismatch is selected.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

vector< ENa_strand > TStrands

TDiag GetDiag(void) const

Get the variant data.

vector< TSignedSeqPos > TStarts

TProduct_type GetProduct_type(void) const

Get the Product_type member data.

TMismatch GetMismatch(void) const

Get the variant data.

TGenomic_strand GetGenomic_strand(void) const

Get the Genomic_strand member data.

void SetType(TType value)

Assign a value to Type data member.

const TParts & GetParts(void) const

Get the Parts member data.

const TProduct_start & GetProduct_start(void) const

Get the Product_start member data.

const TProduct_end & GetProduct_end(void) const

Get the Product_end member data.

const TSpliced & GetSpliced(void) const

Get the variant data.

bool IsGenomic_ins(void) const

Check if variant Genomic_ins is selected.

bool IsMatch(void) const

Check if variant Match is selected.

TGenomic_ins GetGenomic_ins(void) const

Get the variant data.

TStarts & SetStarts(void)

Assign a value to Starts data member.

TStrands & SetStrands(void)

Assign a value to Strands data member.

list< CRef< CSpliced_exon > > TExons

const TExons & GetExons(void) const

Get the Exons member data.

bool IsDisc(void) const

Check if variant Disc is selected.

TType GetType(void) const

Get the Type member data.

bool IsDiag(void) const

Check if variant Diag is selected.

void SetNumseg(TNumseg value)

Assign a value to Numseg data member.

list< CRef< CSpliced_exon_chunk > > TParts

TGenomic_end GetGenomic_end(void) const

Get the Genomic_end member data.

bool IsSpliced(void) const

Check if variant Spliced is selected.

TProduct_strand GetProduct_strand(void) const

Get the Product_strand member data.

list< CRef< CSeq_align > > Tdata

TIds & SetIds(void)

Assign a value to Ids data member.

bool IsProduct_ins(void) const

Check if variant Product_ins is selected.

TProduct_ins GetProduct_ins(void) const

Get the variant data.

const TDisc & GetDisc(void) const

Get the variant data.

TNucpos GetNucpos(void) const

Get the variant 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

@ eType_disc

discontinuous alignment

@ eProduct_type_transcript

const TLoc & GetLoc(void) const

Get the Loc member data.

list< CRef< CCode_break > > TCode_break

const TData & GetData(void) const

Get the Data member data.

const TCode & GetCode(void) const

Get the Code member data.

const TCdregion & GetCdregion(void) const

Get the variant data.

bool CanGetCode(void) const

Check if it is safe to call GetCode method.

const TCode_break & GetCode_break(void) const

Get the Code_break member data.

bool IsSetCode_break(void) const

individual exceptions Check if a value has been assigned to Code_break data member.

ENa_strand

strand of nucleic acid

TIupacna & SetIupacna(void)

Select the variant.

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

static CRef< CSeq_align > s_SplicedToDisc(const CSeq_align &spliced_seg_aln)

static ENa_strand s_GetSeqStrand(const CSeq_align &aln, CSeq_align::TDim row)

static size_t s_GetPolyA_genomic_priming(const CSeq_align &aln, CScope &scope, int neighborhood)

static vector< TSignedSeqPos > s_CalculateStarts(const vector< TSeqPos > &lens, ENa_strand strand, TSeqPos start, TSeqPos end)

static CRef< CDense_seg > s_ExonToDenseg(const CSpliced_exon &exon, ENa_strand product_strand, ENa_strand genomic_strand, const CSeq_id &product_id, const CSeq_id &genomic_id)

#define row(bind, expected)

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