int main()
{
std::ifstream infile("unixdict.txt");
if (!infile)
{
std::cerr << "Can't open word file\n";
return -1;
}
std::vector<std::string> words;
std::string word;
int longest = 0;
while (std::getline(infile, word))
{
int length = word.length();
if (length < longest) continue; // don't test short words
if (ordered(word))
{
if (length > longest)
{
longest = length; // set new minimum length
words.clear(); // reset the container
}
words.push_back(word);
}
}
std::copy(words.begin(), words.end(), std::ostream_iterator<std::string>(std::cout, "\n"));
}
void serialize(const std::vector<Element>& collection,
const std::string& name, Handler&& handler, Args&&... args)
{
const auto call = synchronize(FORWARD_HANDLER(handler),
collection.size(), name);
for (const auto& element: collection)
ordered(BIND_ELEMENT(args, element, call));
}
static void
test_ordered(
unsigned int nparticle
, unsigned int nspecies
, unsigned int repeat
)
{
typedef typename test_suite_type::particle_type particle_type;
typedef typename test_suite_type::particle_group_type particle_group_type;
typedef typename particle_group_type::array_type array_type;
typedef typename particle_group_type::size_type size_type;
typedef typename test_suite_type::all_type all_type;
BOOST_TEST_MESSAGE(" " << "all of " << nparticle << " particles");
BOOST_TEST_MESSAGE(" " << repeat << " iterations");
std::shared_ptr<particle_type> particle = std::make_shared<particle_type>(nparticle, nspecies);
std::shared_ptr<particle_group_type> group = std::make_shared<all_type>(particle);
{
BOOST_CHECK_EQUAL( *group->size(), nparticle );
}
halmd::cache<> size_cache = group->size();
halmd::cache<> ordered_cache = group->ordered();
halmd::accumulator<double> elapsed;
for (size_type i = 0; i < repeat; ++i) {
std::vector<size_type> reverse_tag = make_random_tag(nparticle);
BOOST_CHECK( size_cache == group->size() );
BOOST_CHECK( ordered_cache == group->ordered() );
BOOST_CHECK( set_reverse_tag(
*particle
, reverse_tag.begin()) == reverse_tag.end()
);
{
halmd::scoped_timer<halmd::timer> t(elapsed);
halmd::cache<array_type> const& ordered = group->ordered();
BOOST_CHECK( ordered_cache != ordered );
ordered_cache = ordered;
}
std::vector<size_type> ordered(nparticle);
BOOST_CHECK( get_ordered(
*group
, ordered.begin()) == ordered.end()
);
BOOST_CHECK_EQUAL_COLLECTIONS(
ordered.begin()
, ordered.end()
, reverse_tag.begin()
, reverse_tag.end()
);
}
BOOST_TEST_MESSAGE( " " << mean(elapsed) * 1e3 << " ± " << error_of_mean(elapsed) * 1e3 << " ms per iteration" );
}
void getnn(FILE* fout, Eigen::MatrixXf m, const int idx){
// find nearest neighbour
Eigen::VectorXf dist = (m.rowwise() - m.row(idx)).rowwise().squaredNorm();
std::vector<int> sortidx = ordered(dist);
for (int i=1;i<top;i++){
fprintf(fout, "%s, ", tokename[sortidx[i]]);
}
fprintf(fout, "%s\n", tokename[sortidx[top]]);
}
std::vector<T> reorder ( const std::vector<T> &unordered,
const std::vector<size_t> &sort_order
)
{
// copy for the reorder according to index_map, because unsorted may also be sorted
std::vector<T> ordered (sort_order.size());
for(int i = 0; i<sort_order.size();i++)
{
ordered[i] = unordered[sort_order[i]];
}
return ordered;
}
static int swap(char *s) {
char temp;
int swapped = 0; // falso
while (*s && *(s + 1)) {
if (!ordered(*s, *(s + 1))) {
temp = *s;
*s = *(s + 1);
*(s + 1) = temp;
swapped = 1; // vero
}
s++;
}
return swapped;
}
// A constructor for list nodes.
Table insert(Table t, Key key, Value val)
{
if (t == 0) {
BinTree nodePtr = malloc( sizeof(struct BinNode) );
nodePtr->key = key;
nodePtr->val = val;
nodePtr->left = 0;
nodePtr->right = 0;
return nodePtr;
}
int cmp = compareKey(key, t->key);
if (cmp == -1) {
t->left = insert(t->left, key, val);
} else if (cmp == 1) {
t->right = insert(t->right, key, val);
} else {
t->val = val;
}
assert( ordered(t) );
return t;
}
int main(void){
while(scanf("%d%c",&normal[0],&c)!=EOF){
printf("%d",normal[0]);
order[0] = normal[0];
for(i = 1; c != '\n';order[i] = normal[i],i++)
scanf("%d%c",&normal[i],&c);
pancakes = i;
std::sort(order,order+pancakes);
for(i = 1; i < pancakes; i++) printf(" %d",normal[i]);
putchar('\n');
for(i = 0;!ordered();i++){
if(normal[0] != order[pancakes-i-1]){
for(j = 0; normal[pancakes-j-1] != order[pancakes-i-1]; j++);
printf("%d ",j+1);
std::reverse(normal,normal+pancakes-j);
}
printf("%d ",i+1);
std::reverse(normal,normal+pancakes-i);
}
printf("0\n");
}
}
vector<int> CaffeMobile::predict_top_k(string img_path, int k) {
CHECK(caffe_net != NULL);
Datum datum;
CHECK(ReadImageToDatum(img_path, 0, 256, 256, true, &datum));
const shared_ptr<MemoryDataLayer<float>> memory_data_layer =
static_pointer_cast<MemoryDataLayer<float>>(
caffe_net->layer_by_name("data"));
memory_data_layer->AddDatumVector(vector<Datum>({datum}));
float loss;
vector<Blob<float>* > dummy_bottom_vec;
clock_t t_start = clock();
const vector<Blob<float>*>& result = caffe_net->Forward(dummy_bottom_vec, &loss);
clock_t t_end = clock();
LOG(DEBUG) << "Prediction time: " << 1000.0 * (t_end - t_start) / CLOCKS_PER_SEC << " ms.";
const vector<float> probs = vector<float>(result[1]->cpu_data(), result[1]->cpu_data() + result[1]->count());
CHECK_LE(k, probs.size());
vector<size_t> sorted_index = ordered(probs);
return vector<int>(sorted_index.begin(), sorted_index.begin() + k);
}
multimap<double, IndexDocument*, std::greater<double> > VectorModelSpace::search(Query query) {
multimap<double, IndexDocument*, std::greater<double> > results;
if (mDocuments && mIndex && mDictionary)
{
unordered_map<unsigned int, Query::QueryTerm*> terms = query.mTerms;
unordered_map<unsigned int, Query::QueryTerm*>::iterator it = terms.begin();
unordered_map<unsigned int, Query::QueryTerm*>::iterator end = terms.end();
//writing terms
for (; it != end; ++it) {
Term* term = mDictionary->find(it->second->text);
//calculate weight
if (term) {
//f(t)
it->second->term = *term;
//w(t)
it->second->weightQuery = 1*log2(mCollectionSize/term->frequency);
//for each (d, f(d,t))
recoverIndexTerms(*term, &query);
}
else
it->second->weightQuery = 0;
}
//Cosine
order(&query);
multimap<double, IndexDocument*, std::greater<double> > ordered(query.mIndexDocuments.begin(), query.mIndexDocuments.end());
results = ordered;
}
else
cout << "initSearch before use search method!" << endl;
return results;
}
void Index::printIndex() {
std::map<unsigned int, IndexHeader> ordered(Index::headerIndex.begin(), Index::headerIndex.end());
for ( auto it : ordered )
std::cout << " " << it.first << " " << it.second.block<<" " << it.second.size<<" " << it.second.type<< std::endl;
}
void honTower( Bag *from, Bag *temp, Bag *to )
/////////////////////////////////////////////////////
{
while( from->n > -1 )
//it should/may be from->n >= from->si
// i.e
{
if( from != &a && from->n <= from->si )
return;
int top = from->bag[from->n];
move( from, to );
while( !ordered(to, top ) )
{
if( temp->n == temp->si-1 )
{
if( from->n == from->si )
move( from, to );
else if( from->n == from->si+1 )
{
move( from, temp );
move( from, to );
move( temp, to );
}
else
while( from->n >= from->si )
{
temp->si = temp->n+1;
//if( to->n > 0 )
to->si = to->n+1;
// it may be from->n - from->si +1;
if( ((from->n - from->si + 1) % 2) == 0 )
honTower( from, to, temp );
else
honTower( from, temp, to );
from->si = 0;
//to->si = 0;
//temp->si = 0;
// all element from a is come to b
return;
}
}
if( temp->n == temp->si )
move( temp, to );
else if( temp->n == temp->si+1 )
{
move( temp, from );
move( temp, to );
move( from, to );
}
else
{
while( temp->n > temp->si )
{
from->si = from->n+1;
to->si = to->n+1; // ????????????
if( (temp->n % 2) == 0 )
honTower( temp, from, to );
else
honTower( temp, to, from );
//from->si = 0;
to->si = 0;
// should be
// to->si = 0;
move( temp, to );
continue;
}
}
}
if( from == &a )
if( to == &b )
to = &c, temp = &b;
else
to = &b, temp = &c;
else if( from == &c )
if( to == &b )
to = &a, temp = &b;
else
to = &b, temp = &a;
else if( from = &b )
if( to == &c )
to = &a, temp = &c;
else
to = &c, temp = &a;
}
} // end of honTower
void WorldDownloadManager::removeDuplicatePoints(typename pcl::PointCloud<PointT>::ConstPtr cloud,
TrianglesConstPtr triangles,typename pcl::PointCloud<PointT>::Ptr out_cloud,TrianglesPtr out_triangles)
{
const uint64 input_size = cloud->size();
std::vector<uint64> ordered(input_size);
for (uint64 i = 0; i < input_size; i++)
ordered[i] = i;
std::sort(ordered.begin(),ordered.end(),WorldDownloadManager_mergeMeshTrianglesComparator<PointT>(*cloud));
typedef WorldDownloadManager_mergeMeshTrianglesAverageClass<PointT> AverageClass;
std::vector<uint64> re_association_vector(input_size);
std::vector<AverageClass, Eigen::aligned_allocator<AverageClass> > average_vector;
uint64 output_i = 0;
re_association_vector[ordered[0]] = 0;
for (uint64 src_i = 1; src_i < input_size; src_i++)
{
const PointT & prev = (*cloud)[ordered[src_i - 1]];
const PointT & current = (*cloud)[ordered[src_i]];
const int not_equal = std::memcmp(prev.data,current.data,sizeof(float) * 3);
if (not_equal)
output_i++;
re_association_vector[ordered[src_i]] = output_i;
}
const uint64 output_size = output_i + 1;
out_cloud->resize(output_size);
average_vector.resize(output_size);
for (uint64 i = 0; i < input_size; i++)
average_vector[re_association_vector[i]].insert((*cloud)[i]);
for (uint64 i = 0; i < output_size; i++)
(*out_cloud)[i] = average_vector[i].get();
if (out_triangles && triangles)
{
const uint64 triangles_size = triangles->size();
uint64 out_triangles_size = 0;
out_triangles->resize(triangles_size);
for (uint64 i = 0; i < triangles_size; i++)
{
kinfu_msgs::KinfuMeshTriangle new_tri;
for (uint h = 0; h < 3; h++)
new_tri.vertex_id[h] = re_association_vector[(*triangles)[i].vertex_id[h]];
bool degenerate = false;
for (uint h = 0; h < 3; h++)
if (new_tri.vertex_id[h] == new_tri.vertex_id[(h + 1) % 3])
degenerate = true;
if (!degenerate)
{
(*out_triangles)[out_triangles_size] = new_tri;
out_triangles_size++;
}
}
out_triangles->resize(out_triangles_size);
}
}
