int main ()
{
int result[3];
partial_sort_copy (numbers, numbers + 6, result, result + 3);
for (int i = 0; i < 3; i++)
cout << result[i] << ' ';
cout << endl;
return 0;
}
void FabMapCalculator::WriteLineOfResults_SparseTopK(unsigned int nImageID)
{
//The K largest entries of the current location_probability
//get written out to file in sparse format
m_results_file << "PDF due to image " << nImageID << " :" << endl;
m_results_file << "Milliseconds to calculate: " << 1000.0*m_dfLastPDFCalculationTime << endl;
const unsigned int K = 100;
//Return the probabilities of the K most likely places
//in the format PlaceID:prob
//with PlaceID 0-based
//If there are fewer than K places, return them all
double dfReportingThreshold;
if(location_probability.size() < K)
{
dfReportingThreshold = -1.0; //Less than K places, so we want to return the probability of all places.
}
else
{
//Find the probability of the K-th most likely place.
vector<double> TopK(K);
partial_sort_copy(location_probability.begin(),location_probability.end(),TopK.begin(),TopK.end(),greater<double>());
dfReportingThreshold = TopK[K-1];
}
//Now, add to the output all places where prob is >= dfReportingThreshold, up to a maximum of K places.
vector<double> NonZeroValues;
unsigned int nReported = 0;
unsigned int max = location_probability.size();
for(unsigned int i=0;i<max;i++)
{
if(location_probability[i]>dfReportingThreshold)
{
//Add it to the output
m_results_file << i << " ";
NonZeroValues.push_back(location_probability[i]);
}
if(nReported>K)
break;
}
m_results_file << endl;
//Then write out the corresponding values.
max = NonZeroValues.size();
for(unsigned int i=0; i<max; ++i)
{
m_results_file << NonZeroValues[i] << " ";
}
m_results_file << endl;
//If data association is turned on, also record imageToPlace
#ifdef ALLOW_DATA_ASSOCIATION
m_SceneToPlace_file << m_SceneToPlace.back() << " ";
#endif
}
vector<pair<T_ID, uint32> > InvertedIndexMulDim::topkQuery(vector<int>& queryLow, vector<int>& queryHigh, uint32 k){
map<T_ID,uint32> counter;
scanIndex(queryLow, queryHigh, counter);
vector<pair<T_ID, uint32> > topk(k);
partial_sort_copy(counter.begin(),
counter.end(),
topk.begin(),
topk.end(),
compfunc);
cout<<"topk.size():"<<topk.size()<<endl;
return topk;
}
void sort_algo_demo(){
cout<<endl<<"sort_algo_demo :"<<endl;
int ia[] = {0, 7, 3, 11, 5, 9, 4 , 2, 8};
vector<int> iv(ia,ia+9);vector<int> iv1(9,0);
vector<int>::iterator itr;
cout<<iv<<endl;
// partial_sort_copy()
partial_sort(iv.begin(),iv.begin()+5,iv.end()); //内部采用堆算法，保证前面的middle-first有序
partial_sort_copy(iv.begin(),iv.end(),iv1.begin(),iv1.begin()+4,greater<int>());
cout<<"partial_sort: "<<iv<<endl<<"partial_sort_copy: "<<iv1<<endl;
sort(iv.begin(),iv.end(),greater<int>());
cout<<"sort: "<<iv<<endl;
int ia1[] = {1, 3, 5, 7, 2, 4, 6 , 8, 10};
vector<int> iv2(ia1,ia1+9); vector<int> iv3(ia1,ia1+9);
inplace_merge(iv2.begin(),iv2.begin()+4,iv2.end());
cout<<"inplace_merge: "<<iv2<<endl;
nth_element(iv3.begin(),iv3.begin()+5,iv3.end());
cout<<"nth_element: "<<iv3<<endl<<"5th element: "<<*(iv3.begin()+5)<<endl;
}
vector<long double> mmEM::nViterbi_align(param myParam, vector_str x, vector_str y, vector_2str &alignX, vector_2str &alignY)
{
vector_3qtable Q;
vector<long double> nBestScore;
qtable qtmp;
Q.resize(x.size()+1);
for (int i = 0; i < Q.size() ;i++)
{
Q[i].resize(y.size()+1);
}
qtmp.score = 0;
qtmp.backX = -1;
qtmp.backY = -1;
qtmp.backR = -1;
Q[0][0].push_back(qtmp);
for (int xl =0 ; xl <= x.size(); xl++)
{
for (int yl = 0; yl <= y.size(); yl++)
{
/*if ((xl > 0) || (yl > 0))
{
qtmp.score = LOWLOGPROB;
qtmp.backX = 0;
qtmp.backY = 0;
qtmp.backR = 0;
Q[xl][yl].push_back(qtmp);
}*/
if ( (xl > 0) && (myParam.delX) )
{
for (int i = 1; (i <= myParam.maxX) && (xl-i >=0); i++)
{
string ssX = join(x, xl-i,i);
long double score = (long double) logl(probs[ssX][myParam.nullChar]) * i;
qtmp.backX = i;
qtmp.backY = 0;
for (int rindex = 0; rindex < Q[xl-i][yl].size(); rindex++)
{
qtmp.score = score + Q[xl-i][yl][rindex].score;
qtmp.backR = rindex;
Q[xl][yl].push_back(qtmp);
}
}
}
if ( (yl > 0) && (myParam.delY) )
{
for (int j = 1; (j <= myParam.maxY) && (yl-j >=0); j++)
{
string ssY = join(y, yl-j, j);
long double score = (long double) logl(probs[myParam.nullChar][ssY]) * j;
qtmp.backX = 0;
qtmp.backY = j;
for (int rindex = 0; rindex < Q[xl][yl-j].size(); rindex++)
{
qtmp.score = score + Q[xl][yl-j][rindex].score;
qtmp.backR = rindex;
Q[xl][yl].push_back(qtmp);
}
}
}
if ( (xl > 0) && (yl > 0) )
{
for (int i = 1; (i <= myParam.maxX) && (xl-i >=0); i++)
{
for (int j = 1; (j <= myParam.maxY) && (yl-j >=0); j++)
{
if (! myParam.eqMap)
{
if ((i==j) && (i>1))
{
continue;
}
}
string ssX = join(x, xl-i ,i);
string ssY = join(y, yl-j, j);
long double score = (long double) logl(probs[ssX][ssY]) * max(i,j);
qtmp.backX = i;
qtmp.backY = j;
for (int rindex = 0; rindex < Q[xl-i][yl-j].size(); rindex++)
{
qtmp.score = score + Q[xl-i][yl-j][rindex].score;
qtmp.backR = rindex;
Q[xl][yl].push_back(qtmp);
}
}
}
}
// reduce size of n-best //
if (Q[xl][yl].size() > myParam.nBest)
{
vector_qtable qtmpSort(myParam.nBest);
partial_sort_copy(Q[xl][yl].begin(), Q[xl][yl].end(), qtmpSort.begin(), qtmpSort.end(), DqSortedFn);
Q[xl][yl] = qtmpSort;
}
}
}
// sorting
sort(Q[x.size()][y.size()].begin(), Q[x.size()][y.size()].end(), DqSortedFn);
//backTracking
for (int k=0; ( k < myParam.nBest ) && (Q[x.size()][y.size()].size() > 0) ; k++)
{
long double score = Q[x.size()][y.size()][0].score;
// If the score indicates a proper alignment //
if (score > LOWLOGPROB)
{
int xxl = x.size();
int yyl = y.size();
int moveX;
int moveY;
int backR = 0;
vector_str alignXtmp, alignYtmp;
while ((xxl > 0) || (yyl > 0))
{
moveX = Q[xxl][yyl][backR].backX;
moveY = Q[xxl][yyl][backR].backY;
backR = Q[xxl][yyl][backR].backR;
if (moveX > 0)
{
//alignX->push_back(x.substr(xxl-moveX,moveX));
//alignX->push_back(join(x, xxl-moveX, moveX, myParam.sepInChar));
alignXtmp.push_back(join(x,xxl-moveX, moveX, myParam.sepInChar));
}
else
{
//alignX->push_back(myParam.nullChar);
alignXtmp.push_back(myParam.nullChar);
}
if (moveY > 0)
{
//alignY->push_back(y.substr(yyl-moveY,moveY));
//alignY->push_back(join(y, yyl-moveY, moveY, myParam.sepInChar));
alignYtmp.push_back(join(y, yyl-moveY, moveY, myParam.sepInChar));
}
else
{
//alignY->push_back(myParam.nullChar);
alignYtmp.push_back(myParam.nullChar);
}
xxl -= moveX;
yyl -= moveY;
}
//reverse(alignX->begin(), alignX->end());
//reverse(alignY->begin(), alignY->end());
reverse(alignXtmp.begin(), alignXtmp.end());
reverse(alignYtmp.begin(), alignYtmp.end());
alignX.push_back(alignXtmp);
alignY.push_back(alignYtmp);
nBestScore.push_back(score);
}
// delete top guy //
Q[x.size()][y.size()].erase(Q[x.size()][y.size()].begin());
}
return nBestScore;
}
static void TestAlgorithms (void)
{
static const int c_TestNumbers[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 13, 14, 15, 16, 17, 18 };
const int* first = c_TestNumbers;
const int* last = first + VectorSize(c_TestNumbers);
intvec_t v, buf;
v.assign (first, last);
PrintVector (v);
cout << "swap(1,2)\n";
swap (v[0], v[1]);
PrintVector (v);
v.assign (first, last);
cout << "copy(0,8,9)\n";
copy (v.begin(), v.begin() + 8, v.begin() + 9);
PrintVector (v);
v.assign (first, last);
cout << "copy with back_inserter\n";
v.clear();
copy (first, last, back_inserter(v));
PrintVector (v);
v.assign (first, last);
cout << "copy with inserter\n";
v.clear();
copy (first, first + 5, inserter(v, v.begin()));
copy (first, first + 5, inserter(v, v.begin() + 3));
PrintVector (v);
v.assign (first, last);
cout << "copy_n(0,8,9)\n";
copy_n (v.begin(), 8, v.begin() + 9);
PrintVector (v);
v.assign (first, last);
cout << "copy_if(is_even)\n";
intvec_t v_even;
copy_if (v, back_inserter(v_even), &is_even);
PrintVector (v_even);
v.assign (first, last);
cout << "for_each(printint)\n{ ";
for_each (v, &printint);
cout << "}\n";
cout << "for_each(reverse_iterator, printint)\n{ ";
for_each (v.rbegin(), v.rend(), &printint);
cout << "}\n";
cout << "find(10)\n";
cout.format ("10 found at offset %zd\n", abs_distance (v.begin(), find (v, 10)));
cout << "count(13)\n";
cout.format ("%zu values of 13, %zu values of 18\n", count(v,13), count(v,18));
cout << "transform(sqr)\n";
transform (v, &sqr);
PrintVector (v);
v.assign (first, last);
cout << "replace(13,666)\n";
replace (v, 13, 666);
PrintVector (v);
v.assign (first, last);
cout << "fill(13)\n";
fill (v, 13);
PrintVector (v);
v.assign (first, last);
cout << "fill_n(5, 13)\n";
fill_n (v.begin(), 5, 13);
PrintVector (v);
v.assign (first, last);
cout << "fill 64083 uint8_t(0x41) ";
TestBigFill<uint8_t> (64083, 0x41);
cout << "fill 64083 uint16_t(0x4142) ";
TestBigFill<uint16_t> (64083, 0x4142);
cout << "fill 64083 uint32_t(0x41424344) ";
TestBigFill<uint32_t> (64083, 0x41424344);
cout << "fill 64083 float(0.4242) ";
TestBigFill<float> (64083, 0x4242f);
#if HAVE_INT64_T
cout << "fill 64083 uint64_t(0x4142434445464748) ";
TestBigFill<uint64_t> (64083, UINT64_C(0x4142434445464748));
#else
cout << "No 64bit types available on this platform\n";
#endif
cout << "copy 64083 uint8_t(0x41) ";
TestBigCopy<uint8_t> (64083, 0x41);
cout << "copy 64083 uint16_t(0x4142) ";
TestBigCopy<uint16_t> (64083, 0x4142);
cout << "copy 64083 uint32_t(0x41424344) ";
TestBigCopy<uint32_t> (64083, 0x41424344);
cout << "copy 64083 float(0.4242) ";
TestBigCopy<float> (64083, 0.4242f);
#if HAVE_INT64_T
cout << "copy 64083 uint64_t(0x4142434445464748) ";
TestBigCopy<uint64_t> (64083, UINT64_C(0x4142434445464748));
#else
cout << "No 64bit types available on this platform\n";
#endif
cout << "generate(genint)\n";
generate (v, &genint);
PrintVector (v);
v.assign (first, last);
cout << "rotate(4)\n";
rotate (v, 7);
rotate (v, -3);
PrintVector (v);
v.assign (first, last);
cout << "merge with (3,5,10,11,11,14)\n";
const int c_MergeWith[] = { 3,5,10,11,11,14 };
intvec_t vmerged;
merge (v.begin(), v.end(), VectorRange(c_MergeWith), back_inserter(vmerged));
PrintVector (vmerged);
v.assign (first, last);
cout << "inplace_merge with (3,5,10,11,11,14)\n";
v.insert (v.end(), VectorRange(c_MergeWith));
inplace_merge (v.begin(), v.end() - VectorSize(c_MergeWith), v.end());
PrintVector (v);
v.assign (first, last);
cout << "remove(13)\n";
remove (v, 13);
PrintVector (v);
v.assign (first, last);
cout << "remove (elements 3, 4, 6, 15, and 45)\n";
vector<uoff_t> toRemove;
toRemove.push_back (3);
toRemove.push_back (4);
toRemove.push_back (6);
toRemove.push_back (15);
toRemove.push_back (45);
typedef index_iterate<intvec_t::iterator, vector<uoff_t>::iterator> riiter_t;
riiter_t rfirst = index_iterator (v.begin(), toRemove.begin());
riiter_t rlast = index_iterator (v.begin(), toRemove.end());
remove (v, rfirst, rlast);
PrintVector (v);
v.assign (first, last);
cout << "unique\n";
unique (v);
PrintVector (v);
v.assign (first, last);
cout << "reverse\n";
reverse (v);
PrintVector (v);
v.assign (first, last);
cout << "lower_bound(10)\n";
PrintVector (v);
cout.format ("10 begins at position %zd\n", abs_distance (v.begin(), lower_bound (v, 10)));
v.assign (first, last);
cout << "upper_bound(10)\n";
PrintVector (v);
cout.format ("10 ends at position %zd\n", abs_distance (v.begin(), upper_bound (v, 10)));
v.assign (first, last);
cout << "equal_range(10)\n";
PrintVector (v);
TestEqualRange (v);
v.assign (first, last);
cout << "sort\n";
reverse (v);
PrintVector (v);
random_shuffle (v);
sort (v);
PrintVector (v);
v.assign (first, last);
cout << "stable_sort\n";
reverse (v);
PrintVector (v);
random_shuffle (v);
stable_sort (v);
PrintVector (v);
v.assign (first, last);
cout << "is_sorted\n";
random_shuffle (v);
const bool bNotSorted = is_sorted (v.begin(), v.end());
sort (v);
const bool bSorted = is_sorted (v.begin(), v.end());
cout << "unsorted=" << bNotSorted << ", sorted=" << bSorted << endl;
v.assign (first, last);
cout << "find_first_of\n";
static const int c_FFO[] = { 10000, -34, 14, 27 };
cout.format ("found 14 at position %zd\n", abs_distance (v.begin(), find_first_of (v.begin(), v.end(), VectorRange(c_FFO))));
v.assign (first, last);
static const int LC1[] = { 3, 1, 4, 1, 5, 9, 3 };
static const int LC2[] = { 3, 1, 4, 2, 8, 5, 7 };
static const int LC3[] = { 1, 2, 3, 4 };
static const int LC4[] = { 1, 2, 3, 4, 5 };
cout << "lexicographical_compare";
cout << "\nLC1 < LC2 == " << lexicographical_compare (VectorRange(LC1), VectorRange(LC2));
cout << "\nLC2 < LC2 == " << lexicographical_compare (VectorRange(LC2), VectorRange(LC2));
cout << "\nLC3 < LC4 == " << lexicographical_compare (VectorRange(LC3), VectorRange(LC4));
cout << "\nLC4 < LC1 == " << lexicographical_compare (VectorRange(LC4), VectorRange(LC1));
cout << "\nLC1 < LC4 == " << lexicographical_compare (VectorRange(LC1), VectorRange(LC4));
cout << "\nmax_element\n";
cout.format ("max element is %d\n", *max_element (v.begin(), v.end()));
v.assign (first, last);
cout << "min_element\n";
cout.format ("min element is %d\n", *min_element (v.begin(), v.end()));
v.assign (first, last);
cout << "partial_sort\n";
reverse (v);
partial_sort (v.begin(), v.iat(v.size() / 2), v.end());
PrintVector (v);
v.assign (first, last);
cout << "partial_sort_copy\n";
reverse (v);
buf.resize (v.size());
partial_sort_copy (v.begin(), v.end(), buf.begin(), buf.end());
PrintVector (buf);
v.assign (first, last);
cout << "partition\n";
partition (v.begin(), v.end(), &is_even);
PrintVector (v);
v.assign (first, last);
cout << "stable_partition\n";
stable_partition (v.begin(), v.end(), &is_even);
PrintVector (v);
v.assign (first, last);
cout << "next_permutation\n";
buf.resize (3);
iota (buf.begin(), buf.end(), 1);
PrintVector (buf);
while (next_permutation (buf.begin(), buf.end()))
PrintVector (buf);
cout << "prev_permutation\n";
reverse (buf);
PrintVector (buf);
while (prev_permutation (buf.begin(), buf.end()))
PrintVector (buf);
v.assign (first, last);
cout << "reverse_copy\n";
buf.resize (v.size());
reverse_copy (v.begin(), v.end(), buf.begin());
PrintVector (buf);
v.assign (first, last);
cout << "rotate_copy\n";
buf.resize (v.size());
rotate_copy (v.begin(), v.iat (v.size() / 3), v.end(), buf.begin());
PrintVector (buf);
v.assign (first, last);
static const int c_Search1[] = { 5, 6, 7, 8, 9 }, c_Search2[] = { 10, 10, 11, 14 };
cout << "search\n";
cout.format ("{5,6,7,8,9} at %zd\n", abs_distance (v.begin(), search (v.begin(), v.end(), VectorRange(c_Search1))));
cout.format ("{10,10,11,14} at %zd\n", abs_distance (v.begin(), search (v.begin(), v.end(), VectorRange(c_Search2))));
cout << "find_end\n";
cout.format ("{5,6,7,8,9} at %zd\n", abs_distance (v.begin(), find_end (v.begin(), v.end(), VectorRange(c_Search1))));
cout.format ("{10,10,11,14} at %zd\n", abs_distance (v.begin(), find_end (v.begin(), v.end(), VectorRange(c_Search2))));
cout << "search_n\n";
cout.format ("{14} at %zd\n", abs_distance (v.begin(), search_n (v.begin(), v.end(), 1, 14)));
cout.format ("{13,13} at %zd\n", abs_distance (v.begin(), search_n (v.begin(), v.end(), 2, 13)));
cout.format ("{10,10,10} at %zd\n", abs_distance (v.begin(), search_n (v.begin(), v.end(), 3, 10)));
v.assign (first, last);
cout << "includes\n";
static const int c_Includes[] = { 5, 14, 15, 18, 20 };
cout << "includes=" << includes (v.begin(), v.end(), VectorRange(c_Includes)-1);
cout << ", not includes=" << includes (v.begin(), v.end(), VectorRange(c_Includes));
cout << endl;
static const int c_Set1[] = { 1, 2, 3, 4, 5, 6 }, c_Set2[] = { 4, 4, 6, 7, 8 };
intvec_t::iterator setEnd;
cout << "set_difference\n";
v.resize (4);
setEnd = set_difference (VectorRange(c_Set1), VectorRange(c_Set2), v.begin());
PrintVector (v);
assert (setEnd == v.end());
cout << "set_symmetric_difference\n";
v.resize (7);
setEnd = set_symmetric_difference (VectorRange(c_Set1), VectorRange(c_Set2), v.begin());
PrintVector (v);
assert (setEnd == v.end());
cout << "set_intersection\n";
v.resize (2);
setEnd = set_intersection (VectorRange(c_Set1), VectorRange(c_Set2), v.begin());
PrintVector (v);
assert (setEnd == v.end());
cout << "set_union\n";
v.resize (9);
setEnd = set_union (VectorRange(c_Set1), VectorRange(c_Set2), v.begin());
PrintVector (v);
assert (setEnd == v.end());
v.assign (first, last);
}