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

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

NCBI C++ ToolKit: include/algo/align/util/compartment_finder.hpp Source File

<

THit>

<

THit>

(

= 0;

<

->size(); ++

) {

gfrom = (*m_gaps)[

].first;

gto = (*m_gaps)[

].second;

( gfrom < to && from < gto ) {

vector<pair<TCoord, TCoord> > *

;

<

THit>

THitRefs::const_iterator finish,

(

cross_filter =

);

THitRefs::iterator ihr,

THitRefs::iterator ihr_e,

min_compartment_hit_len);

<

THit>

cross_filter =

);

THitRefs::iterator finish,

cross_filter =

,

*scope =

,

vector<pair<TCoord, TCoord> > *gaps =

);

(

THitRefs::iterator start,

THitRefs::iterator finish,

*scope =

,

vector<pair<TCoord, TCoord> > *gaps =

);

valid_count (0);

pair<size_t, size_t> rv (

.size(), valid_count);

min_singleton_matches,

cross_filter);

<

THit>

<

THit>

(m_members.size()) {

m_members.front()->GetSubjStrand();

);

<

THit>

THitRefs::const_iterator start,

THitRefs::const_iterator finish,

<

THit>

qmax (ph->GetQueryMax());

acm + ph->GetIdentity() * ((

= qmax) - qmin + 1);

acm + ph->GetIdentity() * ((

= qmax) - finish0);

<

THit>

THitComparator sorter (THitComparator::eQueryMin);

stable_sort(hitrefs.begin(), hitrefs.end(), sorter);

rv (accumulate(hitrefs.begin(), hitrefs.end(), 0.0,

<

THit>

kMinusInf (-1e12);

m_compartments.clear();

dimhits = m_hitrefs.size();

stable_sort(m_hitrefs.begin(), m_hitrefs.end(),

THitComparator(THitComparator::eSubjMaxQueryMax));

vector<SHitStatus> THitData;

THitData hitstatus (dimhits);

subj_min_global (m_hitrefs.front()->GetSubjMin());

(

(0); i < static_cast<int>(dimhits); ++

) {

identity (h->GetIdentity());

h->GetQueryMin(), h->GetQueryMax(),

h->GetSubjMin(), h->GetSubjMax()

cerr << endl << *h << endl;

best_ext_score (kMinusInf);

best_open_score (identity*(hbox[1] - hbox[0] + 1) - m_penalty);

i_best_open (-1);

(hbox[2] + m_max_overlap > m_hitrefs[i_bestsofar]->GetSubjMax()) {

score_open (identity*(hbox[1] - hbox[0] + 1)

+ hitstatus[i_bestsofar].m_score

(score_open > best_open_score) {

best_open_score = score_open;

i_best_open = i_bestsofar;

(

j (

- 1); j >= 0; --j) {

score_open (identity * (hbox[1] - hbox[0] + 1)

+ hitstatus[j].m_score

(score_open > best_open_score

&& hbox[2] + m_max_overlap > m_hitrefs[j]->GetSubjMax())

best_open_score = score_open;

(

j =

; j >= 0; --j) {

phcbox[0] = phc->GetQueryMin();

phcbox[1] = phc->GetQueryMax();

phcbox[2] = phc->GetSubjMin();

phcbox[3] = phc->GetSubjMax();

cerr <<

<< *phc << endl;

cerr <<

<< endl;

( ( phcbox[1] < hbox[1] && phcbox[0] < hbox[0] )

&& phcbox[2] <= hbox[2]

(hbox[0] <= phcbox[1] &&

hbox[2] + phcbox[1] - hbox[0] >= phcbox[3]) {

s0 = hbox[2] + phcbox[1] - hbox[0];

(phcbox[3] >= hbox[2]) {

q0 = hbox[1] - (hbox[3] - s0);

subj_space = s0 - phcbox[3] - 1;

good = (subj_space <=

(m_intron_max))

&& (s0 < hbox[3] && q0 < hbox[1]);

( phcbox[3] <= hbox[2] ) {

( ( m_prec_gap_info && m_prec_gap_info->IntersectsNonBridgeableGap(phcbox[3], hbox[2]) ) ||

( m_gap_info && m_gap_info->IntersectsNonBridgeableGap(phcbox[3], hbox[2]) ) ) {

intron_start = phcbox[3];

jscore (hitstatus[j].m_score);

intron_penalty ((subj_space > 0)?

ext_score (jscore +

identity * (hbox[1] - q0 + 1) + intron_penalty);

(ext_score > best_ext_score) {

best_ext_score = ext_score;

cerr <<

<< ext_score << endl;

(best_ext_score > best_open_score) {

hit_type = SHitStatus::eExtension;

prev_hit = i_best_ext;

best_score = best_ext_score;

hit_type = SHitStatus::eOpening;

prev_hit = i_best_open;

best_score = best_open_score;

hitstatus[

].m_type = hit_type;

hitstatus[

].m_prev = prev_hit;

hitstatus[

].m_score = best_score;

(best_score > hitstatus[i_bestsofar].m_score) {

cerr <<

<< ((hit_type == SHitStatus::eOpening)?

:

)

<<

<< best_score << endl;

(prev_hit == -1) {

cerr <<

<< endl;

cerr << *(m_hitrefs[prev_hit]) << endl;

cerr <<

;

score_best (hitstatus[i_bestsofar].m_score);

min_matches (m_MinSingletonMatches < m_MinMatches?

m_MinSingletonMatches: m_MinMatches);

vector<bool> comp_status;

(score_best + m_penalty >= min_matches) {

new_compartment (

);

(new_compartment) {

mp (GetTotalMatches<THit>(hitrefs));

m_compartments.back().SetMembers() = hitrefs;

comp_status.push_back(mp >= m_MinMatches);

new_compartment =

;

hitrefs.push_back(m_hitrefs[

]);

cerr << *(m_hitrefs[

]) << endl;

(hitstatus[

].m_type == SHitStatus::eOpening) {

new_compartment =

;

= hitstatus[

].m_prev;

mp (GetTotalMatches<THit>(hitrefs));

status ( ( m_compartments.size() == 0 && mp >= m_MinSingletonMatches )

|| mp >= m_MinMatches );

m_compartments.back().SetMembers() = hitrefs;

comp_status.push_back(status);

(cross_filter && m_compartments.size()) {

kMinCompartmentHitLength (8);

(

icn (m_compartments.size()), ic (0); ic < icn; ++ic) {

nullified (0);

(

(

(hitrefs.size())),

(

- 1);

> 0; --

) {

(j1 <

&& hitrefs[j1].IsNull()) ++j1;

(j1 ==

)

;

(h1.

())

;

* box1o (h1->GetBox());

box1 [4] = {box1o[0], box1o[1], box1o[2], box1o[3]};

* box2o (h2->GetBox());

box2 [4] = {box2o[0], box2o[1], box2o[2], box2o[3]};

qd (box1[1] - box2[0] + 1);

sd (box1[3] - box2[2] + 1);

(qd > sd && qd > 0) {

(box2[0] <= box1[0] + kMinCompartmentHitLength) {

new_coord (box1[0] + (box1[1] - box1[0])/2);

(box1[0] + 1 <= new_coord) {

h1->Modify(1, new_coord);

h1->Modify(1, box2[0] - 1);

(box2[1] <= box1[1] + kMinCompartmentHitLength) {

new_coord (box2[0] + (box2[1] - box2[0])/2);

(box2[1] >= new_coord + 1) {

new_coord = box2[1];

h2->Modify(0, new_coord);

h2->Modify(0, box1[1] + 1);

(box2[2] <= box1[2] + kMinCompartmentHitLength) {

(

+ 1 ==

) {

new_coord (box1[2] + (box1[3] - box1[2])/2);

(box1[2] + 1 <= new_coord) {

new_coord = box1[2];

h1->Modify(3, new_coord);

h1->Modify(3, box2[2] - 1);

(box2[3] <= box1[3] + kMinCompartmentHitLength) {

new_coord (box2[2] + (box2[3] - box2[2])/2);

(box2[3] >= new_coord + 1) {

new_coord = box2[3];

h2->Modify(2, new_coord);

h2->Modify(2, box1[3] + 1);

(nullified > 0) {

hitrefs.erase(

(hitrefs.begin(), hitrefs.end(),

THitRefs::iterator ihr_b (m_hitrefs.begin()),

ihr_e(m_hitrefs.end()), ihr (ihr_b);

stable_sort(ihr_b, ihr_e, THitComparator(THitComparator::eSubjMinSubjMax));

(

icn (

(m_compartments.size())), ic (icn - 1); ic >= 0; --ic) {

(hitrefs.size() < 3) {

(*ii)->SetScore(- (*ii)->GetScore());

hitrefs.front()->SetEValue(-1);

hitrefs.back()->SetEValue(-1);

comp_subj_min (hitrefs.back()->GetSubjStart());

comp_subj_max (hitrefs.front()->GetSubjStop());

(ihr != ihr_e && ((*ihr)->GetSubjStart() < comp_subj_min

|| (*ihr)->GetScore() < 0))

(ihr == ihr_e)

;

((*ihr)->GetSubjStart() > comp_subj_max)

;

THitRefs::iterator ihrc_b (ihr);

THitRefs::iterator ihrc_e (ihr);

(ihrc_e != ihr_e && ((*ihrc_e)->GetSubjStart() < comp_subj_max

|| (*ihrc_e)->GetScore() < 0))

nullified (sx_XFilter(hitrefs, ihrc_b, ihrc_e, 1,

kMinCompartmentHitLength));

stable_sort(ihrc_b, ihrc_e, THitComparator (THitComparator::eQueryMinQueryMax));

nullified += sx_XFilter(hitrefs, ihrc_b, ihrc_e, 0,

kMinCompartmentHitLength);

(nullified > 0) {

hitrefs.erase(

(hitrefs.begin(), hitrefs.end(),

(

icn (

(m_compartments.size())), ic (icn - 1); ic >= 0; --ic) {

score ((*ii)->GetScore());

(*ii)->SetScore(-score);

eval ((*ii)->GetEValue());

(*ii)->SetEValue(0);

(

(0),

(m_compartments.size());

<

; ++

) {

(comp_status[

] ==

) {

& hitrefs (m_compartments[

].SetMembers());

hr->SetScore(-hr->GetScore());

m_compartments.size();

<

THit>

THitRefs::iterator ihr,

THitRefs::iterator ihr_e,

min_compartment_hit_len)

nullified (0);

(

(

(hitrefs.size())),

(

- 2);

> 0 && ihr != ihr_e; --

) {

(h1.

())

;

* box1o (h1->GetBox());

box1 [4] = {box1o[0], box1o[1], box1o[2], box1o[3]};

(; ihr != ihr_e; ++ihr) {

(hr.

())

;

(hr->GetScore() > 0 && hr->GetStop(w) >= box1[2*w]) {

ls0 (box1[2*w+1] + 1), cursegmax (0);

segmax_start(box1[2*w]), segmax_stop(box1[2*w+1]);

(box1[2*w] < (*ihr)->GetStart(w)) {

segmax_start = ls0 = box1[2*w];

segmax_stop = (*ihr)->GetStart(w) - 1;

cursegmax = segmax_stop - segmax_start + 1;

shrsmax ((*ihr)->GetStop(w));

(++ihr; ihr != ihr_e; ++ihr) {

(hr.

() || hr->GetScore() < 0) {

hrs0 (hr->GetStart(w));

(hrs0 > box1[2*w+1]) {

segmax_stop = box1[2*w+1];

(hrs0 > shrsmax) {

segmax_stop = hrs0 - 1;

hrs1 (hr->GetStop(w));

(hrs1 > shrsmax) {

(shrsmax < box1[2*w+1]) {

segmax_start = ls0 = shrsmax + 1;

cursegmax = segmax_stop - segmax_start + 1;

(ls0 > box1[2*w+1]) {

(; ihr != ihr_e; ++ihr) {

(hr.

() || hr->GetScore() < 0) {

hrs0 (hr->GetStart(w));

(hrs0 > box1[2*w+1]) {

(ls0 <= box1[2*w+1] && box1[2*w+1] + 1 - ls0 > cursegmax) {

segmax_stop = box1[2*w+1];

cursegmax = segmax_stop - segmax_start + 1;

(hrs0 - ls0 > cursegmax) {

segmax_stop = hrs0 - 1;

cursegmax = segmax_stop - segmax_start + 1;

ls0 = hr->GetStop(w) + 1;

(hr->GetStop(w) + 1 > ls0) {

ls0 = hr->GetStop(w) + 1;

(box1[2*w+1] > ls0 + cursegmax) {

segmax_stop = box1[2*w+1];

cursegmax = segmax_stop - segmax_start + 1;

(cursegmax < min_compartment_hit_len) {

(box1[2*w] < segmax_start) {

h1->Modify(2 * w, segmax_start);

(segmax_stop < box1[2*w+1]) {

h1->Modify(2 * w + 1, segmax_stop);

(ihr == ihr_e)

;

<

THit>

(m_compartments.size()) {

&m_compartments[m_iter++];

<

THit>

(

= 0, dim = m_compartments.size();

< dim; ++

) {

m_compartments[

].UpdateMinMax();

stable_sort(m_compartments.begin(), m_compartments.end(),

<

THit>

dim = m_compartments.size();

(m_iter == -1 || m_iter >=

(dim)) {

&m_compartments[m_iter++];

<

THit>

min_singleton_matches,

x_Init(comp_penalty, min_matches, min_singleton_matches, cross_filter);

<

THit>

THitRefs::iterator istart,

THitRefs::iterator ifinish,

min_singleton_matches,

vector<pair<TCoord, TCoord> > *gaps)

x_Init(comp_penalty, min_matches, min_singleton_matches, cross_filter);

(istart, ifinish, scope, gaps);

<

THit>

min_singleton_matches,

m_Penalty = comp_penalty;

m_MinMatches = min_matches;

m_MinSingletonMatches = min_singleton_matches;

m_CrossFiltering = cross_filter;

<

THit>

THitRefs::iterator ifinish,

vector<pair<TCoord, TCoord> > *gaps)

(istart == ifinish)

;

THitRefs::iterator ib = istart, ie = ifinish, ii = ib,

THitComparator sorter (THitComparator::eSubjStrand);

stable_sort(ib, ie, sorter);

minus_subj_min = kMax_TCoord, minus_subj_max = 0;

(ii = ib; ii != ie; ++ii) {

((*ii)->GetSubjStrand()) {

((*ii)->GetSubjMin() < minus_subj_min) {

minus_subj_min = (*ii)->GetSubjMin();

((*ii)->GetSubjMax() > minus_subj_max) {

minus_subj_max = (*ii)->GetSubjMax();

gapi.

(minus_subj_min, minus_subj_max);

prec_gapi.

(minus_subj_min, minus_subj_max);

(ii = ib; ii != iplus_beg; ++ii) {

s0 = minus_subj_min + minus_subj_max

- (*ii)->GetSubjMax();

s1 = minus_subj_min + minus_subj_max

- (*ii)->GetSubjMin();

(*ii)->SetSubjStart(s0);

(*ii)->SetSubjStop(s1);

finder.

(m_CrossFiltering);

(ii = ib; ii != iplus_beg; ++ii) {

s0 = minus_subj_min + minus_subj_max

- (*ii)->GetSubjMax();

s1 = minus_subj_min + minus_subj_max

- (*ii)->GetSubjMin();

(*ii)->SetSubjStart(s1);

(*ii)->SetSubjStop(s0);

x_Copy2Pending(finder);

finder.

(m_CrossFiltering);

x_Copy2Pending(finder);

<

THit>

(compartment->GetMembers().size() > 0) {

m_pending.push_back(

(0));

(

ph (compartment->GetFirst()); ph; ph = compartment->GetNext())

* box = compartment->GetBox();

m_ranges.push_back(box[0]);

m_ranges.push_back(box[1]);

m_ranges.push_back(box[2]);

m_ranges.push_back(box[3]);

m_strands.push_back(compartment->GetStrand());

m_status.push_back(compartment->GetFirst()->GetScore() > 0);

<

THit>

GetNext(compartment);

<

THit>

compartment.clear();

(m_iter < m_pending.size()) {

compartment = m_pending[m_iter++];

<

THit>

(m_pending.size()) {

(m_pending.front().size()) {

& h (*m_pending.front().front());

(

(0), idim(m_pending.size());

< idim; ++

) {

(m_status[

]) {

range_min (

> 0 && m_strands[

-1] == m_strands[

]

? m_ranges[4*

- 1]

range_max (

+ 1 < idim && m_strands[

+1] == m_strands[

]

? m_ranges[4*

+ 6]

range_max, subj_strand));

.push_back(seq_loc);

& h (**ii);

(transcript.empty()) {

sa3->

().SetStd().push_back(sg);

sg->SetLoc().push_back(query_loc);

sg->SetLoc().push_back(subj_loc);

ds.

().push_back(seqid_query);

ds.

().push_back(seqid_subj);

sas2_data.push_back(sa3);

sas1_data.push_back(sa2);

User-defined methods of the data storage class.

void remove_if(Container &c, Predicate *__pred)

TCoord GetQueryStart(void) const

const TId & GetSubjId(void) const

TCoord GetQueryMin(void) const

TCoord GetSubjStart(void) const

const TId & GetQueryId(void) const

TCoord GetSubjMin(void) const

TCoord GetQueryMax(void) const

TCoord GetSubjMax(void) const

const TTranscript & GetTranscript(void) const

void Run(typename THitRefs::iterator start, typename THitRefs::iterator finish, CScope *scope=NULL, const vector< pair< TCoord, TCoord > > *gaps=NULL)

Execute: identify compartments.

bool GetStrand(size_t i) const

void SetMaxIntron(TCoord mi)

Assign the maximum intron length, in base pairs.

bool GetFirst(THitRefs &compartment)

Initialize iteration over the results.

CRef< objects::CSeq_align_set > AsSeqAlignSet(void) const

Retrieve all valid compartments in a seq-align-set.

TCoord m_MinSingletonMatches

void x_Init(TCoord comp_penalty, TCoord min_matches, TCoord min_singleton_matches, bool cross_filter)

void Get(size_t idx, THitRefs &compartment) const

Retrieve a compartment by index.

const TCoord * GetBox(size_t i) const

TCompartmentFinder::THitRefs THitRefs

CCompartmentAccessor(TCoord comp_penalty_bps, TCoord min_matches, TCoord min_singleton_matches=numeric_limits< TCoord >::max(), bool cross_filter=false)

Construct the object and assign the parameters of the algorithm.

TCompartmentFinder::TCoord TCoord

void SetMaxOverlap(TCoord max_overlap)

Assign the maximum length for compartments to overlap on the subject.

vector< TCoord > m_ranges

vector< THitRefs > m_pending

bool GetNext(THitRefs &compartment)

Proceed with iteration over the results.

bool GetStatus(size_t i) const

TCoord GetMaxIntron(void) const

Retrieve the maximum intron length, in base pairs.

pair< size_t, size_t > GetCounts(void) const

Retrieve the compartment counts.

CCompartmentFinder< THit > TCompartmentFinder

void x_Copy2Pending(TCompartmentFinder &finder)

Individual compartment representation.

const THitRef GetNext(void) const

Retrieve the next member.

void AddMember(const THitRef &hitref)

Add a new member into the compartment.

const TCoord * GetBox(void) const

Retrieve the compartment's box.

const THitRefs & GetMembers(void)

Retrieve compartment's members.

static bool s_PLowerSubj(const CCompartment &c1, const CCompartment &c2)

bool GetStrand(void) const

Retrieve the compartment's strand (true == plus)

void UpdateMinMax(void)

Make sure the compartment's box is up-to-date.

CCompartment(void)

Create an empty compartment.

THitRefs & SetMembers(void)

Assign all members of the compartment.

const THitRef GetFirst(void) const

Retrieve the first member.

void SetMaxIntron(TCoord intr_max)

Set the maximum length of an intron.

static TCoord s_GetDefaultMaxOverlap(void)

Retrieve the default compartment overlap behaviour (no overlap).

static TCoord s_GetDefaultMinCoverage(void)

Retrieve the default minimum coverage, in base pairs.

void SetMinMatches(TCoord min_matches)

Set the minimum matching residues per compartment.

void SetPenalty(TCoord penalty)

Set the penalty to open a compartment.

vector< CCompartment > m_compartments

static TCoord s_GetDefaultPenalty(void)

Retrieve the default compartment penalty, in base pairs.

size_t Run(bool cross_filter=false)

Identify compartments.

vector< THitRef > THitRefs

CCompartment * GetNext(void)

TCoord m_MinSingletonMatches

CPrecalcGapInfo< THit > * m_prec_gap_info

static TCoord s_GetDefaultMaxIntron(void)

Retrieve the default maximum length of an intron.

void SetMinSingletonMatches(TCoord min_matches)

Set the minimum matching residues per singleton compartment.

CCompartmentFinder(typename THitRefs::const_iterator start, typename THitRefs::const_iterator finish, CGapInfo< THit > *gap_info=NULL, CPrecalcGapInfo< THit > *prec_gap_info=NULL)

Create the object from the complete set of local alignments (hits) between the transcript and the gen...

static bool s_PNullRef(const THitRef &hr)

CGapInfo< THit > * m_gap_info

void OrderCompartments(void)

Order compartments by lower subj coordinate.

void SetMaxOverlap(TCoord max_overlap)

Set compartment overlap behaviour.

static size_t sx_XFilter(THitRefs &hitrefs, typename THitRefs::iterator ihr, typename THitRefs::iterator ihr_e, Uint1 w, size_t min_compartment_hit_len)

CCompartment * GetFirst(void)

void FromTranscript(TSeqPos query_start, ENa_strand query_strand, TSeqPos subj_start, ENa_strand subj_strand, const string &transcript)

Initialize from pairwise alignment transcript (a string representation produced by CNWAligner)

void Flip(TCoord subj_min, TCoord subj_max)

CGapInfo(const CSeq_id &id, CScope *scope)

CConstRef< CSeqMap > m_seq_map

bool IntersectsNonBridgeableGap(TCoord from, TCoord to)

CPrecalcGapInfo(const vector< pair< TCoord, TCoord > > *gaps)

const vector< pair< TCoord, TCoord > > * m_gaps

bool IntersectsNonBridgeableGap(TCoord from, TCoord to)

void Flip(TCoord subj_min, TCoord subj_max)

CQueryMatchAccumulator(void)

double operator()(double acm, CRef< THit > ph)

const double kPenaltyPerIntronPos

double GetTotalMatches(const typename CCompartmentFinder< THit >::THitRefs &hitrefs0)

const double kPenaltyPerIntronBase

IMPLEMENTATION.

CSplign::THitRefs THitRefs

static const char * bounds[]

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

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

virtual void Assign(const CSerialObject &source, ESerialRecursionMode how=eRecursive)

Optimized implementation of CSerialObject::Assign, which is not so efficient.

CBioseq_Handle GetBioseqHandle(const CSeq_id &id)

Get bioseq handle by seq-id.

const CSeqMap & GetSeqMap(void) const

Get sequence map.

CConstRef< CSeq_literal > GetRefGapLiteral(void) const

return CSeq_literal with gap data, or null if either the segment is not a gap, or an unspecified gap

CSeqMap_CI ResolvedRangeIterator(CScope *scope, TSeqPos from, TSeqPos length, ENa_strand strand=eNa_strand_plus, size_t maxResolve=size_t(-1), TFlags flags=fDefaultFlags) const

Iterate segments in the range with specified strand coordinates.

void Reset(void)

Reset reference object.

bool IsNull(void) const THROWS_NONE

Check if pointer is null – same effect as Empty().

uint8_t Uint1

1-byte (8-bit) unsigned integer

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

void Run(void)

Enter the main loop.

Tdata & Set(void)

Assign a value to data member.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

void SetType(TType value)

Assign a value to Type data member.

list< CRef< CSeq_loc > > TBounds

list< CRef< CSeq_align > > Tdata

TIds & SetIds(void)

Assign a value to Ids data member.

TBounds & SetBounds(void)

Assign a value to Bounds data member.

@ eType_disc

discontinuous alignment

ENa_strand

strand of nucleic acid

unsigned int

A callback function used to compare two keys in a database.

std::istream & in(std::istream &in_, double &x_)

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

SHitStatus(EType type, int prev, double score)

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