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

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

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

((*seg_it)->GetLoc().size() != 2) {

);

);

traceback =

.GetTraceback(align, 0);

(traceback.empty()) {

);

(

, it, traceback) {

product_pos +=

* product_dir;

genomic_pos +=

* genomic_dir;

genomic_ins = *it ==

;

product_ins = *++it ==

;

(!genomic_ins && !product_ins) {

product_pos, product_pos);

genomic_pos, genomic_pos);

product_pos += product_dir;

genomic_pos += genomic_dir;

(product_pos != (product_dir == 1 ? align.

(0)+1

|| genomic_pos != (genomic_dir == 1 ? align.

(1)+1

+ traceback);

product_dir = is_product_minus ||

genomic_dir = is_genomic_minus ||

((*part_it)->Which()) {

product_mismatch_end = product_pos +

product_dir * ((*part_it)->GetMismatch()-1);

(product_pos,product_mismatch_end),

(product_pos,product_mismatch_end));

genomic_mismatch_end = genomic_pos +

genomic_dir * ((*part_it)->GetMismatch()-1);

(genomic_pos,genomic_mismatch_end),

(genomic_pos,genomic_mismatch_end));

product_pos += product_dir * (*part_it)->GetMismatch();

genomic_pos += genomic_dir * (*part_it)->GetMismatch();

product_pos += product_dir * (*part_it)->GetMatch();

genomic_pos += genomic_dir * (*part_it)->GetMatch();

product_pos += product_dir * (*part_it)->GetProduct_ins();

genomic_pos += genomic_dir * (*part_it)->GetGenomic_ins();

);

((*it)->GetSeqRange(0), (*it)->GetSeqRange(1), align_info,

);

seg.

()[1]->GetTotalRange(), align_info,

);

);

);

genomic(first_exon->GetGenomic_end(),

second_exon->GetGenomic_start());

product.

(last_exon->GetProduct_end().AsSeqPos());

product.

(exon->GetProduct_start().AsSeqPos());

<

T>

vector<string> &score_list,

required =

)

(vector<string>, it, score_list) {

scores.push_back(

);

score_set_as_blacklist,

(score_set_as_blacklist) {

((*score_it)->GetId().IsStr() &&

!score_set.count((*score_it)->GetId().GetStr()))

((*score_it)->GetValue().IsInt()) {

integer_scores[(*score_it)->GetId().GetStr()] =

(*score_it)->GetValue().GetInt();

real_scores[(*score_it)->GetId().GetStr()] =

(*score_it)->GetValue().GetReal();

(

.IsIntegerScore(align, *score_it)) {

integer_scores[*score_it] =

(

);

real_scores[*score_it] =

;

real_score_tolerance)

it2 = scores2.

();

it1 != scores1.

() || it2 != scores2.

(); ++it1, ++it2)

(it1 == scores1.

() || it2 == scores2.

()

|| it1->first != it2->first)

allowed_diff =

(

(it1->second),

(it2->second))

* real_score_tolerance;

(

(it1->second - it2->second) > allowed_diff) {

ext_set_as_blacklist,

(!ext_set_as_blacklist && !ext_set.

()) {

(!(*ext_it)->GetType().IsStr()) {

ext_type = (*ext_it)->GetType().GetStr();

is_in_set = ext_set.count(ext_type);

((ext_set_as_blacklist && !is_in_set)||

(!ext_set_as_blacklist && is_in_set))

exts[ext_type] = *ext_it;

(!ext_set_as_blacklist && exts.

() < ext_set.

()) {

(

= 0;

< length;

++) {

top = (ptr[

] & 0xf0) >> 4;

bot = (ptr[

] & 0x0f);

exts1_wstr(&exts1_md5), exts2_wstr(&exts2_md5);

it2 = exts2.

();

it1 != exts1.

() || it2 != exts2.

(); ++it1, ++it2)

(it1 == exts1.

() || it2 == exts2.

()

|| it1->first != it2->first)

exts1_md5_array[16], exts2_md5_array[16];

memset(exts1_md5_array, 0, 16);

memset(exts2_md5_array, 0, 16);

exts1_md5.GetChecksum().GetMD5Digest(exts1_md5_array);

real_score_tolerance);

, spans_unique_first(0)

, spans_unique_second(0)

, is_equivalent(

)

real_score_tolerance)

, spans_unique_first(0)

, spans_unique_second(0)

, is_equivalent(

)

(

.CompareGroup(second,

) != 0) {

( ; first_it !=

.spans.end() && second_it != second.

.

(); ) {

(*first_it == *second_it) {

intersecting_len = first_it->first.GetLength();

dot += float(intersecting_len) * float(intersecting_len);

sum_a += first_it->first.GetLength() * first_it->first.GetLength();

sum_b += second_it->first.GetLength() * second_it->first.GetLength();

first_it->first.IntersectingWith(second_it->first) &&

first_it->second.IntersectingWith(second_it->second);

.IntersectWith(second_it->first);

intersecting_len =

.GetLength();

dot += float(intersecting_len) * float(intersecting_len);

(*first_it < *second_it) {

sum_a += first_it->first.GetLength() * first_it->first.GetLength();

sum_b += second_it->first.GetLength() * second_it->first.GetLength();

real_score_tolerance) &&

( ; first_it !=

.spans.end(); ++first_it) {

sum_a += first_it->first.GetLength() * first_it->first.GetLength();

( ; second_it != second.

.

(); ++second_it) {

sum_b += second_it->first.GetLength() * second_it->first.GetLength();

= dot == 0 ? 0 : dot / ::sqrt(sum_a * sum_b);

(k2.

< k1.

) {

; }

pair<CAlignCompare::SAlignment *, CAlignCompare::SAlignment *>

;

pair<TPtrPair, SComparison>

;

(c1.second.is_equivalent && !c2.second.is_equivalent) {

(c2.second.is_equivalent && !c1.second.is_equivalent) {

(c1.second.is_equivalent && !c2.second.is_equivalent) {

(c2.second.is_equivalent && !c1.second.is_equivalent) {

(c1.first.first->subject_range < c2.first.first->subject_range)

(c2.first.first->subject_range < c1.first.first->subject_range)

c1.first.second->query_range < c2.first.second->query_range;

, compare_object(compare)

(compare.

) {

+= it->first.GetLength();

(scores.first < o.

.first) {

-1; }

(o.

.first < scores.first) {

1; }

(

score_index = 0; score_index < scores.second.size(); ++score_index) {

(scores.second[score_index] && o.

.second[score_index]) {

(scores.second[score_index] < o.

.second[score_index]) {

-1; }

(o.

.second[score_index] < scores.second[score_index]) {

1; }

(compare_group < 0) {

}

(compare_group > 0) {

list< AutoPtr<SAlignment> > &current_group =

list< AutoPtr<SAlignment> > &next_group =

current_group.clear();

current_group.splice(current_group.end(), next_group);

(!

.EndOfData() && next_group.empty()) {

(current_group.empty() || align->CompareGroup(*current_group.front(),

) == 0)

current_group.push_back(align);

next_group.push_back(align);

compare_object.m_BoundariesMap[

].insert(it->second.GetFrom());

compare_object.m_BoundariesMap[

].insert(it->second.GetToOpen());

compare_object.m_BoundariesMap[

].insert(it->first.GetFrom());

compare_object.m_BoundariesMap[

].insert(it->first.GetToOpen());

list< AutoPtr<SAlignment> > align_parts;

range =

== 0 ? query_range : subject_range;

it != boundaries.

() && *it <= range.

(); ++it)

align_parts.push_back(part);

(!align_parts.empty() && last_boundary < range.

()) {

align_parts.push_back(part);

(align->GetSegs().IsDisc()) {

vector< AutoPtr<SAlignment> > seg_slices;

slice_range & (*seg_it)->GetSeqRange(

);

(seg_slice_range.

()) {

(source_set, *seg_it, compare_object) . Slice(

seg_slices.push_back(slice);

(seg_slices.size() == 1) {

complete_slice = seg_slices.front();

}

(seg_slices.size() > 1) {

compare_object,

));

complete_align->

().SetDisc().Set().push_back(

complete_slice->query_mismatches += (*seg_it)->query_mismatches;

complete_slice->subject_mismatches += (*seg_it)->query_mismatches;

complete_slice;

(!align->GetSegs().IsDenseg()) {

);

slice_align->

(align->GetType());

(align->IsSetDim()) {

slice_align->

(align->GetDim());

all_gaps =

;

(

seg = 0; seg < slice_seg->

() && all_gaps; ++seg) {

(slice_seg->

()[seg*2] >= 0 &&

slice_align->

().SetDenseg(*slice_seg);

((*score_it)->GetId().IsStr() &&

compare_object.m_DistributiveScores.count(

(*score_it)->GetId().GetStr()))

slice_align->

().push_back(*score_it);

slice.

(

(source_set, slice_align, compare_object,

));

(compare_object.m_Mode ==

) {

slice->query_mismatches = query_mismatches;

slice->query_mismatches &= slice_align->

(0);

slice->subject_mismatches = subject_mismatches;

slice->subject_mismatches &= slice_align->

(1);

list< AutoPtr<SAlignment> > orig_set;

list< AutoPtr<SAlignment> > &transformed_set =

: transformed_set.front()->subject;

orig_set.swap(transformed_set);

list< AutoPtr<CAlignCompare::SAlignment> > parts =

(*it)->BreakOnBoundaries(

);

transformed_set.push_back(*it);

transformed_set.splice(transformed_set.end(), parts);

(next_group_set & 1) {

(next_group_set & 2) {

vector<const SAlignment *> group;

(next_group_set) {

group.push_back(&**it);

group.push_back(&**it);

set1_aligns.

(&**it);

set2_aligns.

(&**it);

vector<TComp> comparisons;

(

&& red_color.count(rhs) > 0 ) {

& record = comparisons.back();

pair<TAlignPtrSet, EMatchLevel> TAlignGroup;

list<TAlignGroup> groups;

(vector<TComp>, it, comparisons) {

is_equivalent = it->second.is_equivalent;

(is_equivalent ||

(it->second.overlap > 0 &&

it->first.first->match_level !=

&&

it->first.second->match_level !=

))

list<TAlignGroup>::iterator align1_group = groups.end(),

align2_group = groups.end();

(set1_aligns.

(it->first.first)) {

it->first.first->match_level =

group.push_back(it->first.first);

(is_equivalent) {

+ it->second.spans_overlap;

align1_group = group_map[it->first.first];

(set2_aligns.

(it->first.second)) {

it->first.second->match_level =

group.push_back(it->first.second);

(is_equivalent) {

+ it->second.spans_overlap;

align2_group = group_map[it->first.second];

(align1_group == groups.end() &&

align2_group == groups.end())

list<TAlignGroup>::iterator new_group =

groups.

(groups.end(), TAlignGroup());

new_group->first.insert(it->first.first);

new_group->first.insert(it->first.second);

new_group->second = it->first.first->match_level;

group_map[it->first.first] = new_group;

group_map[it->first.second] = new_group;

}

(align1_group == groups.end()) {

align2_group->first.

(it->first.first);

group_map[it->first.first] = align2_group;

}

(align2_group == groups.end()) {

align1_group->first.

(it->first.second);

group_map[it->first.second] = align1_group;

}

(align1_group != align2_group) {

align1_group->first.insert(*group2_it);

group_map[*group2_it] = align1_group;

(align2_group->second ==

) {

(align1_group->second ==

) {

groups.erase(align2_group);

(list<TAlignGroup>, group_it, groups) {

vector<SAlignment *> best(3,

*

(

));

*&side_best = best[(*align_it)->source_set];

side_best = *align_it;

(best[1]->quality_scores != best[2]->quality_scores) {

(*align_it)->match_level =

(*align_it)->source_set == better_side

((*align1_it)->source_set != 1) {

((*align2_it)->source_set != 2) {

(*align1_it)->matched_alignments.push_back(*align2_it);

(*align2_it)->matched_alignments.push_back(*align1_it);

(vector<TComp>, comp_it, comparisons) {

(set1_aligns.

() && set2_aligns.

()) {

(comp_it->second.overlap == 0) {

(set1_aligns.

(comp_it->first.first)) {

group.push_back(comp_it->first.first);

(set2_aligns.

(comp_it->first.second)) {

group.push_back(comp_it->first.second);

group.push_back(*set1_it);

group.push_back(*set2_it);

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.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

bool s_IsOverlapping(CAlignCompare::SAlignment const *lhs, CAlignCompare::SAlignment const *rhs, CAlignCompare::ERowComparison row)

static bool s_EquivalentScores(const CAlignCompare::TRealScoreSet &scores1, const CAlignCompare::TRealScoreSet &scores2, double real_score_tolerance)

static void s_GetAlignmentMismatches(const CSeq_align &align, CAlignCompare::SAlignment &align_info, CAlignCompare::ERowComparison row)

static void s_GetAlignmentSpans_Exon(const CSeq_align &align, CAlignCompare::SAlignment &align_info, CAlignCompare::ERowComparison row)

static void s_PopulateScoreSet(const CSeq_align &align, const set< string > &score_set, bool score_set_as_blacklist, CAlignCompare::TIntegerScoreSet &integer_scores, CAlignCompare::TRealScoreSet &real_scores)

pair< TPtrPair, SComparison > TComp

static void s_PopulateExtSet(const CSeq_align &align, const set< string > &ext_set, bool ext_set_as_blacklist, CAlignCompare::TExtSet &exts)

pair< CAlignCompare::SAlignment *, CAlignCompare::SAlignment * > TPtrPair

static bool s_EquivalentExts(const CAlignCompare::TExtSet &exts1, const CAlignCompare::TExtSet &exts2)

void s_PopulateScores(const CSeq_align &align, const vector< string > &score_list, vector< T > &scores, bool required=true)

static void s_UpdateSpans(const TSeqRange &query_range, const TSeqRange &subject_range, CAlignCompare::SAlignment &align_info, CAlignCompare::ERowComparison row)

static void s_GetAlignmentSpans_Interval(const CSeq_align &align, CAlignCompare::SAlignment &align_info, CAlignCompare::ERowComparison row)

string s_ConvertToHexString(unsigned char *ptr, unsigned int length)

set< CAlignCompare::SAlignment *, SAlignment_PtrLess > TAlignPtrSet

static void s_GetAlignmentSpans_Intron(const CSeq_align &align, CAlignCompare::SAlignment &align_info, CAlignCompare::ERowComparison row)

static void s_GetAlignmentSpans_Span(const CSeq_align &align, CAlignCompare::SAlignment &align_info, CAlignCompare::ERowComparison row)

void ConvertSeqAlignToPairwiseAln(CPairwiseAln &pairwise_aln, const objects::CSeq_align &sa, objects::CSeq_align::TDim row_1, objects::CSeq_align::TDim row_2, CAlnUserOptions::EDirection direction=CAlnUserOptions::eBothDirections, const TAlnSeqIdVec *ids=0)

Build pairwise alignment from the selected rows of a seq-align.

Checksum and hash calculation classes.

vector< const SAlignment * > NextGroup()

size_t m_CountOverlapGroups

int x_DetermineNextGroupSet()

Determine whether the next group of alignments should be taken from set 1 or 2.

list< AutoPtr< SAlignment > > m_NextSet2Group

list< AutoPtr< SAlignment > > m_NextSet1Group

size_t m_CountBasesOverlapSet2

list< AutoPtr< SAlignment > > m_CurrentSet2Group

size_t m_CountBasesOnlySet2

size_t m_CountBasesEquivSet1

map< CSeq_id_Handle, set< TSeqPos > > m_BoundariesMap

size_t m_CountBasesEquivSet2

void x_SplitOnOverlaps(int group, int row)

size_t m_CountOverlapSet1

void PopulateBoundariesMap()

double m_RealScoreTolerance

bool m_ScoreSetAsBlacklist

AutoPtr< SAlignment > x_NextAlignment(int set, bool update_counts=true)

Get next alignment from the correct set.

TDisambiguatingScoreList m_DisambiguitingScores

size_t m_CountBasesOverlapSet1

void x_GetCurrentGroup(int set)

list< AutoPtr< SAlignment > > m_CurrentSet1Group

size_t m_CountBasesOnlySet1

vector< string > m_QualityScores

size_t m_CountEquivGroups

size_t m_CountOverlapSet2

CAlignRange Represents an element of pairwise alignment of two sequences.

Default IAlnSeqId implementation based on CSeq_id_Handle.

CChecksumStreamWriter –.

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

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

A pairwise aln is a collection of ranges for a pair of rows.

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

Writer-based output stream.

virtual bool EndOfData() const =0

container_type::const_iterator const_iterator

const_iterator begin() const

const_iterator end() const

iterator_bool insert(const value_type &val)

iterator_bool insert(const value_type &val)

const_iterator upper_bound(const key_type &key) const

const_iterator end() const

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

static int lookup(const char *name, const struct lookup_int *table)

void reset(element_type *p=0, EOwnership ownership=eTakeOwnership)

Reset will delete the old pointer (if owned), set content to the new value, and assume the ownership ...

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

element_type * get(void) const

Get pointer.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

void GetMD5Digest(unsigned char digest[16]) const

Return calculated MD5 digest.

const CChecksum & GetChecksum(void) const

Return checksum.

#define ERR_POST(message)

Error posting with file, line number information but without error codes.

void Error(CExceptionArgs_Base &args)

TErrCode GetErrCode(void) const

Get error code.

#define NCBI_THROW(exception_class, err_code, message)

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

#define MSerial_AsnBinary

#define MSerial_AsnText

I/O stream manipulators –.

static CSeq_id_Handle GetHandle(const CSeq_id &id)

Normal way of getting a handle, works for any seq-id.

string AsString(void) const

TRange GetTotalRange(void) const

int64_t Int8

8-byte (64-bit) signed integer

bool IntersectingWith(const TThisType &r) const

position_type GetToOpen(void) const

CRange< TSeqPos > TSeqRange

typedefs for sequence ranges

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

static enable_if< is_arithmetic< TNumeric >::value||is_convertible< TNumeric, Int8 >::value, string >::type NumericToString(TNumeric value, TNumToStringFlags flags=0, int base=10)

Convert numeric value to string.

void SetFrom(TFrom value)

Assign a value to From data member.

TTo GetTo(void) const

Get the To member data.

TFrom GetFrom(void) const

Get the From member data.

void SetTo(TTo value)

Assign a value to To data member.

bool IsSetProduct_strand(void) const

should be 'plus' or 'minus' Check if a value has been assigned to Product_strand data member.

TScore & SetScore(void)

Assign a value to Score data member.

E_Choice Which(void) const

Which variant is currently selected.

bool IsSetParts(void) const

basic seqments always are in biologic order Check if a value has been assigned to Parts data member.

vector< CRef< CScore > > TScore

const TLoc & GetLoc(void) const

Get the Loc member data.

list< CRef< CStd_seg > > TStd

bool IsSetExt(void) const

extra info Check if a value has been assigned to Ext data member.

bool IsSetProduct_strand(void) const

should be 'plus' or 'minus' Check if a value has been assigned to Product_strand data member.

const TStarts & GetStarts(void) const

Get the Starts member data.

TGenomic_start GetGenomic_start(void) const

Get the Genomic_start member data.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

void SetDim(TDim value)

Assign a value to Dim data member.

TGenomic_strand GetGenomic_strand(void) const

Get the Genomic_strand member data.

list< CRef< CUser_object > > TExt

bool IsSetGenomic_strand(void) const

genomic-strand represents the strand of translation Check if a value has been assigned to Genomic_str...

bool CanGetProduct_strand(void) const

Check if it is safe to call GetProduct_strand method.

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 IsSetGenomic_strand(void) const

Check if a value has been assigned to Genomic_strand data member.

const TStd & GetStd(void) const

Get the variant data.

list< CRef< CSpliced_exon > > TExons

const TExons & GetExons(void) const

Get the Exons member data.

TGenomic_strand GetGenomic_strand(void) const

Get the Genomic_strand member data.

TProduct_strand GetProduct_strand(void) const

Get the Product_strand member data.

const TExt & GetExt(void) const

Get the Ext member data.

list< CRef< CSpliced_exon_chunk > > TParts

bool IsSetScore(void) const

for whole alignment Check if a value has been assigned to Score data member.

TGenomic_end GetGenomic_end(void) const

Get the Genomic_end member data.

bool IsSpliced(void) const

Check if variant Spliced is selected.

TNumseg GetNumseg(void) const

Get the Numseg member data.

TProduct_strand GetProduct_strand(void) const

Get the Product_strand member data.

list< CRef< CSeq_align > > Tdata

const TScore & GetScore(void) const

Get the Score member data.

const TDisc & GetDisc(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.

bool CanGetGenomic_strand(void) const

Check if it is safe to call GetGenomic_strand method.

@ e_Product_ins

insertion in product sequence (i.e. gap in the genomic sequence)

@ e_Genomic_ins

insertion in genomic sequence (i.e. gap in the product sequence)

@ e_Match

both sequences represented, product and genomic sequences match

@ e_Mismatch

both sequences represented, product and genomic sequences do not match

bool IsEmpty(void) const

Check if variant Empty is selected.

bool IsInt(void) const

Check if variant Int is selected.

bool IsNull(void) const

Check if variant Null is selected.

constexpr auto sort(_Init &&init)

const GenericPointer< typename T::ValueType > T2 value

const CharType(& source)[N]

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

static int match(PCRE2_SPTR start_eptr, PCRE2_SPTR start_ecode, uint16_t top_bracket, PCRE2_SIZE frame_size, pcre2_match_data *match_data, match_block *mb)

Reader-writer based streams.

static const sljit_gpr r1

static const sljit_gpr r0

#define row(bind, expected)

TDisambiguatingScoreValues scores

TRealScoreSet real_scores

vector< double > quality_scores

int CompareGroup(const SAlignment &o, bool strict_only) const

void PopulateBoundariesMap() const

list< AutoPtr< SAlignment > > BreakOnBoundaries(int row) const

SAlignment(int s, const CRef< CSeq_align > &al, CAlignCompare &compare, bool is_slice=false)

ENa_strand subject_strand

TIntegerScoreSet integer_scores

CRangeCollection< TSeqPos > query_mismatches

AutoPtr< SAlignment > Slice(int row, TSeqPos from, TSeqPos to) const

CRangeCollection< TSeqPos > subject_mismatches

bool operator()(const CAlignCompare::SAlignment *ptr1, const CAlignCompare::SAlignment *ptr2) const

bool operator()(const TComp &c1, const TComp &c2) const

SComp_Less(bool strict=false)

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