RetroSearch Browse

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

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

NCBI C++ ToolKit: include/algo/text/vector_impl.hpp Source File

40 #ifndef ALGO_TEXT___VECTOR__HPP 41 # error This file should never be included directly 65 template

class

68 bool operator()

(

const

pair<T,U>& it1,

const

pair<T,U>& it2)

const 70 return

(it1.first < it2.first);

75 template

class

78 bool operator()

(

const

pair<T,U>& it1,

const

pair<T,U>& it2)

const 80 return

(it2.second < it1.second);

89 template

class

Key,

class

Score>

97 template

class

Key,

class

Score>

105 template

class

Key,

class

Score>

114 template

class

Key,

class

Score>

118 if

(

this

!= &other) {

120

m_Uid = other.

m_Uid

;

126 template

class

Key,

class

Score>

131

m_Data.reserve(vec.

size

());

134 ITERATE

(

typename

TOtherVector, iter, vec) {

138

m_Uid = vec.

GetId

();

145 template

class

Key,

class

Score>

149 if

(

this

!= &other) {

150

m_Data.swap(other.

m_Data

);

156 template

class

Key,

class

Score>

164 template

class

Key,

class

Score>

172 template

class

Key,

class

Score>

176 return

m_Data.size();

180 template

class

Key,

class

Score>

188 template

class

Key,

class

Score>

193 return

m_Data.begin();

197 template

class

Key,

class

Score>

206 template

class

Key,

class

Score>

211 return

m_Data.begin();

215 template

class

Key,

class

Score>

224 template

class

Key,

class

Score>

230 return

std::find(m_Data.begin(), m_Data.end(), v);

234 template

class

Key,

class

Score>

240 return

std::find(m_Data.begin(), m_Data.end(), v);

244 template

class

Key,

class

Score>

252 template

class

Key,

class

Score>

261 template

class

Key,

class

Score>

266 iterator

iter = lower_bound(m_Data.begin(), m_Data.end(), p,

268 if

(iter == m_Data.end() || iter->first !=

val

.first) {

269

m_Data.insert(iter,

val

);

271

iter->second =

val

.second;

276 template

class

Key,

class

Score>

287 _ASSERT

(

== m_Data.end() ||

->first != it->first);

290

m_Data.insert(ins_before, start, stop);

294 template

class

Key,

class

Score>

298 return

m_Data.empty();

302 template

class

Key,

class

Score>

307 const_iterator

iter = lower_bound(m_Data.begin(), m_Data.end(), p,

309 if

(iter == m_Data.end() || iter->first != idx) {

317 template

class

Key,

class

Score>

325 template

class

Key,

class

Score>

330 size_t

diff = end_in - begin_in;

331

m_Data.reserve(m_Data.size() + diff);

332 size_t

orig_size = m_Data.size();

334 bool

need_sort =

false

;

335 for

( ; begin_in != end_in; ++begin_in) {

337

lower_bound(m_Data.begin(), m_Data.begin() + orig_size,

339 if

(iter == m_Data.end() || iter->first != begin_in->first) {

340

m_Data.push_back(*begin_in);

343

iter->second = begin_in->second;

348 if

(

is_sorted

(m_Data.begin() + orig_size, m_Data.end())) {

349

std::inplace_merge(m_Data.begin(),

350

m_Data.begin() + orig_size,

361 template

class

Key,

class

Score>

366 iterator

iter = lower_bound(m_Data.begin(), m_Data.end(), p,

368 if

(iter == m_Data.end() || iter->first != idx) {

369

m_Data.insert(iter, p);

377 template

class

Key,

class

Score>

392

Score length = Length() * trim_pct;

394 for

( ; iter != m_Data.end(); ++iter) {

395

sum += iter->second * iter->second;

396 if

(sqrt(sum) >= length) {

402 if

(iter == m_Data.begin()) {

408 for

(; iter != m_Data.end() && iter->second ==

->second; ++iter) {

412

m_Data.erase(iter, m_Data.end());

418 template

class

Key,

class

Score>

422

max_words =

max

(max_words, (

size_t

)1);

423 if

(m_Data.size() <= max_words) {

432 iterator

iter = m_Data.begin() + max_words - 1;

436 for

(; iter != m_Data.end() && iter->second ==

->second; ++iter) {

440 if

(iter != m_Data.end()) {

441

m_Data.erase(iter, m_Data.end());

450 template

class

Key,

class

Score>

460 for

( ; iter != m_Data.end(); ++iter) {

461 if

(iter->second < min_score) {

468 for

(; iter != m_Data.end() && iter->second ==

->second; ++iter) {

472

m_Data.erase(iter, m_Data.end());

478 template

class

Key,

class

Score>

487 template

class

Key,

class

Score>

499 template

class

Key,

class

Score>

505 len

+= iter->second * iter->second;

511 template

class

Key,

class

Score>

515 return

sqrt(Length2());

519 template

class

Key,

class

Score>

523

Score inv_len = Length();

525

inv_len = 1.0f / inv_len;

528

iter->second *= inv_len;

534 template

class

Key,

class

Score>

540

inv_len += iter->second;

543

inv_len = 1.0f / inv_len;

546

iter->second *= inv_len;

552 template

class

Key,

class

Score>

558 size_t

diff = end_in - begin_in;

559 size_t

orig_size = m_Data.size();

560

m_Data.reserve(m_Data.size() + diff);

562 bool

need_sort =

false

;

563 for

( ; begin_in != end_in; ++begin_in) {

564 iterator

pseudo_end = m_Data.begin() + orig_size;

566

lower_bound(m_Data.begin(), pseudo_end,

568 if

(iter == pseudo_end || iter->first != begin_in->first) {

569

m_Data.push_back(*begin_in);

572

iter->second += begin_in->second;

578

std::inplace_merge(m_Data.begin(),

579

m_Data.begin() + orig_size,

592 template

class

Key,

class

Score>

600 for

( ; iter1 != m_Data.end() && iter2 != other.

m_Data

.end(); ) {

601 if

(iter1->first == iter2->first) {

602

iter1->second -= iter2->second;

606 if

(iter1->first < iter2->first) {

609 TIdxScore

p(iter2->first, -iter2->second);

610

iter1 = m_Data.insert(iter1, p);

616 for

( ; iter2 != other.

m_Data

.end(); ++iter2) {

617 TIdxScore

p(iter2->first, -iter2->second);

625 template

class

Key,

class

Score>

630

iter->second *=

val

;

636 template

class

Key,

class

Score>

645

iter->second *=

val

;

656 template

class

Key,

class

Score>

665 template

class

Key,

class

Score>

674 template

class

Key,

class

Score>

683 template

class

Key,

class

Score>

687 if

(

this

!= &other) {

689

m_Uid = other.

m_Uid

;

695 template

class

Key,

class

Score>

701 ITERATE

(

typename

TOtherVector, iter, other) {

702

m_Data.insert(m_Data.end(),

value_type

(iter->first, iter->second));

704

m_Uid = other.

GetId

();

709 template

class

Key,

class

Score>

717 template

class

Key,

class

Score>

725 template

class

Key,

class

Score>

729 return

m_Data.size();

733 template

class

Key,

class

Score>

737 return

m_Data.begin();

741 template

class

Key,

class

Score>

749 template

class

Key,

class

Score>

753 return

m_Data.begin();

757 template

class

Key,

class

Score>

765 template

class

Key,

class

Score>

770 return

m_Data.find(

key

);

774 template

class

Key,

class

Score>

779 return

m_Data.find(

key

);

783 template

class

Key,

class

Score>

788 return

m_Data.insert(hint, v);

792 template

class

Key,

class

Score>

794

pair<typename CScoreVector<Key, Score>::iterator,

bool

797 return

m_Data.insert(v);

801 template

class

Key,

class

Score>

810 template

class

Key,

class

Score>

818 template

class

Key,

class

Score>

826 template

class

Key,

class

Score>

830 return

m_Data.empty();

834 template

class

Key,

class

Score>

838 if

(

this

!= &other) {

839

m_Data.swap(other.

m_Data

);

845 template

class

Key,

class

Score>

850 if

(iter == m_Data.end()) {

858 template

class

Key,

class

Score>

863 if

(iter == m_Data.end()) {

871 template

class

Key,

class

Score>

878

magnitude += Score(iter->second) * Score(iter->second);

881

magnitude = 1.0f / sqrt(magnitude);

883

iter->second *= magnitude;

889 template

class

Key,

class

Score>

895

inv_len += iter->second;

898

inv_len = 1.0f / inv_len;

901

iter->second *= inv_len;

907 template

class

Key,

class

Score>

925 template

class

Key,

class

Score>

931 len

+= iter->second * iter->second;

937 template

class

Key,

class

Score>

941 return

sqrt(Length2());

945 template

class

Key,

class

Score>

950

iter->second *=

val

;

956 template

class

Key,

class

Score>

962

iter->second *=

val

;

968 template

class

Key,

class

Score>

977 for

( ; iter1 != end1 && iter2 != end2; ) {

978 if

(iter1->first == iter2->first) {

979

iter1->second += iter2->second;

983 if

(iter1->first < iter2->first) {

986

m_Data.insert(iter1, *iter2);

992 for

( ; iter2 != end2; ++iter2) {

1001 template

class

Key,

class

Score>

1010 for

( ; iter1 != end1 && iter2 != end2; ) {

1011 if

(iter1->first == iter2->first) {

1012

iter1->second -= iter2->second;

1016 if

(iter1->first < iter2->first) {

1020

m_Data.insert(iter1,

val

);

1026 for

( ; iter2 != end2; ++iter2) {

1028

m_Data.insert(iter1,

val

);

1035 template

class

Key,

class

Score>

1039 if

(trim_pct < 1.0f) {

1042 typedef

vector< pair<Key, Score> > TInvVector;

1050

trim_pct *= Length();

1052 typename

TInvVector::iterator iter = v.begin();

1053 typename

TInvVector::iterator iter_end = v.end();

1056 for

( ; iter != iter_end && sqrt(sum) < trim_pct; ++iter) {

1057

sum += iter->second * iter->second;

1061 typename

TInvVector::iterator

= iter;

1062 if

(

!= v.begin()) {

1065 for

(; iter != iter_end &&

->first == iter->first; ++iter) {

1069 for

( ; iter != iter_end; ++iter) {

1070

Set().erase(iter->first);

1075 template

class

Key,

class

Score>

1079 if

(max_words < m_Data.size()) {

1082 typedef

vector< pair<Key, Score> > TInvVector;

1090 typename

TInvVector::iterator iter = v.begin() + max_words;

1091 typename

TInvVector::iterator

= iter - 1;

1092 typename

TInvVector::iterator iter_end = v.end();

1093 for

( ; iter != iter_end &&

->first == iter->first; ++iter) {

1097 for

( ; iter != iter_end; ++iter) {

1098

m_Data.erase(iter->first);

1103 template

class

Key,

class

Score>

1109 for

( ; iter != m_Data.end(); ) {

1110 if

(iter->second < min_score) {

1111

m_Data.erase(iter++);

1120 template

class

Key,

class

Score>

1129 for

( ; iter1 != end1 && iter2 != end2; ) {

1130 if

(iter1->first == iter2->first) {

1134 if

(iter1->first < iter2->first) {

1137

m_Data.insert(iter1,

1145 for

( ; iter2 != end2; ++iter2) {

1147

m_Data.insert(iter1,

1154 template

class

Key,

class

Score>

1163 for

( ; iter1 != end1 && iter2 != end2; ) {

1164 if

(iter1->first == iter2->first) {

1165

iter1->second += iter2->second;

1169 if

(iter1->first < iter2->first) {

1172

m_Data.insert(iter1, *iter2);

1178 for

( ; iter2 != end2; ++iter2) {

1180

m_Data.insert(iter1,

1190 template

class

ScoreVectorA,

class

ScoreVectorB>

1194 typename

ScoreVectorA::score_type dot = 0;

1195 typename

ScoreVectorA::score_type distance = 0;

1197

vec2.begin(), vec2.end(),

1199 return

dot * distance / (vec1.Length() * vec2.Length());

1203 template

class

ScoreVectorA,

class

ScoreVectorB>

1205 float ScoreCosine

(

const

ScoreVectorA& vec1,

const

ScoreVectorB& vec2)

1208

vec2.begin(), vec2.end());

1218 template

class

ScoreVectorA,

class

ScoreVectorB>

1220 float ScoreDice

(

const

ScoreVectorA& vec_a,

const

ScoreVectorB& vec_b)

1222 return ncbi::Dice

(vec_a.begin(), vec_a.end(),

1223

vec_b.begin(), vec_b.end());

1227 template

class

ScoreVectorA,

class

ScoreVectorB>

1232

vec_b.begin(), vec_b.end());

1236 template

class

ScoreVectorA,

class

ScoreVectorB>

1238 float ScoreDot

(

const

ScoreVectorA& vec_a,

const

ScoreVectorB& vec_b)

1240 return ncbi::Dot

(vec_a.begin(), vec_a.end(),

1241

vec_b.begin(), vec_b.end());

1251 template

class

ScoreVectorA,

class

ScoreVectorB>

1256

vec_b.begin(), vec_b.end());

1264 template

class

ScoreVectorA,

class

ScoreVectorB>

1269

vec_b.begin(), vec_b.end());

class CRawScoreVector stores its data in a (sorted) STL vector this gives a better memory profile and...

void TrimThresh(Score min_score)

vector< TIdxScore > TVector

CRawScoreVector< Key, Score > & operator+=(const CRawScoreVector< Key, Score > &other)

void TrimLength(float trim_pct)

virtual void Swap(CRawScoreVector< Key, Score > &other)

void SortByIndex()

re-sort the vector by index.

TVector::const_iterator const_iterator

key_type GetId() const

setup functions

void TrimCount(size_t max_words)

pair< Key, Score > TIdxScore

const TVector & Get() const

void insert(const value_type &val)

void SortByScore()

force the vector to be sorted in order of descending score

iterator find(const Key &key)

key_type m_Uid

UID for this set.

void reserve(size_t size)

CRawScoreVector & operator=(const CScoreVector< Key, Score > &)

float Length2() const

math functions

TVector m_Data

the data for this document

CRawScoreVector< Key, Score > & operator/=(Score val)

void Add(Key idx, Score weight=Score(1))

TVector::iterator iterator

CRawScoreVector< Key, Score > & operator*=(Score val)

CRawScoreVector< Key, Score > & operator-=(const CRawScoreVector< Key, Score > &other)

void TrimThresh(Score min_score)

CScoreVector< Key, Score > & operator-=(const CScoreVector< Key, Score > &other)

TVector::const_iterator const_iterator

const TVector & Get() const

iterator find(const Key &key)

CScoreVector< Key, Score > & operator/=(Score val)

void TrimLength(float trim_pct)

CScoreVector & operator=(const CScoreVector< Key, Score > &other)

void SubtractMissing(const CScoreVector< Key, Score > &other)

pair< iterator, bool > insert(const value_type &val)

CScoreVector< Key, Score > & operator*=(Score val)

CScoreVector< Key, Score > & operator+=(const CScoreVector< Key, Score > &other)

TVector m_Data

the data for this document

float Length2() const

math functions

key_type m_Uid

UID for this set.

void Add(Key idx, Score weight=Score(1))

TVector::value_type value_type

TVector::iterator iterator

key_type GetId() const

setup functions

virtual void Swap(CScoreVector< Key, Score > &other)

void TrimCount(size_t max_words)

void AddScores(const CScoreVector< Key, Score > &other)

const_iterator begin() const

const_iterator end() const

const_iterator find(const key_type &key) const

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.

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

BEGIN_STD_SCOPE bool is_sorted(Iterator iter1, Iterator iter2)

is_sorted is provided by some implementations of the STL and may be included in future releases of al...

const TYPE & Get(const CNamedParameterList *param)

constexpr auto sort(_Init &&init)

double value_type

The numeric datatype used by the parser.

const struct ncbi::grid::netcache::search::fields::SIZE size

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

Useful/utility classes and methods.

bool operator()(const pair< T, U > &it1, const pair< T, U > &it2) const

float ScoreCosine(const ScoreVectorA &vec1, const ScoreVectorB &vec2)

float ScoreDot(const ScoreVectorA &vec_a, const ScoreVectorB &vec_b)

float ScoreDistance(const ScoreVectorA &vec_a, const ScoreVectorB &vec_b)

float ScoreDice(const ScoreVectorA &vec_a, const ScoreVectorB &vec_b)

The dice coefficient is defined as.

float ScoreCombined(const ScoreVectorA &vec1, const ScoreVectorB &vec2)

float ScoreJaccard(const ScoreVectorA &vec_a, const ScoreVectorB &vec_b)

The Jaccard coefficient is defined as.

float ScoreOverlap(const ScoreVectorA &vec_a, const ScoreVectorB &vec_b)

The overlap function is a dot product weighted by the *shortest* of each term.

string InitialValue< string >(string *)

float Dice(iterator1 iter1, iterator1 end1, iterator2 iter2, iterator2 end2)

Dice coefficient.

float Distance(iterator1 iter1, iterator1 end1, iterator2 iter2, iterator2 end2)

Euclidean distance measure.

float Dot(iterator1 iter1, iterator1 end1, iterator2 iter2, iterator2 end2)

Dot-product similarity.

float Jaccard(iterator1 iter1, iterator1 end1, iterator2 iter2, iterator2 end2)

Jaccard similarity.

float Cosine(iterator1 iter1, iterator1 end1, iterator2 iter2, iterator2 end2)

Cosine similarity measure.

float Overlap(iterator1 iter1, iterator1 end1, iterator2 iter2, iterator2 end2)

Overlap measure.

void DotAndDistance(iterator1 iter1, iterator1 end1, iterator2 iter2, iterator2 end2, float *dot_in, float *dist_in)

Dot and distance in one step.

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