void init(){ string ff; hash_map<int, string> user; ifstream fin("in"); int k = 0; while (true){ if (fin.eof())break; fin >> ff; vector<string> tmp; split(ff, ",", tmp); hash_map<string, vector<Node>*>::iterator it = mylog.find(tmp[0]); if (it == mylog.end()){ vector<Node>* newVector = new vector<Node>(); mylog[tmp[0]] = newVector; user[k++] = tmp[0]; } mylog[tmp[0]]->push_back(Node(tmp[0], tmp[1], tmp[2], tmp[3])); } fin.close(); hash_map<string, vector<Node>*>::iterator it; for (it = mylog.begin(); it != mylog.end(); it++){ vector<string> v; net[it->first] = v; for (int i = 0; i < 5; i++){ int ran = rand() % 9999; net[it->first].push_back(user[ran]); } } }
void query_recommender::merge_recommended_queries(std::multimap<double,std::string,std::less<double> > &related_queries, hash_map<const char*,double,hash<const char*>,eqstr> &update) { hash_map<const char*,double,hash<const char*>,eqstr>::iterator hit; std::multimap<double,std::string,std::less<double> >::iterator mit = related_queries.begin(); while(mit!=related_queries.end()) { std::string rquery = (*mit).second; if ((hit = update.find(rquery.c_str()))!=update.end()) { (*hit).second = std::min((*mit).first,(*hit).second); std::multimap<double,std::string,std::less<double> >::iterator mit2 = mit; ++mit; related_queries.erase(mit2); } else ++mit; } hit = update.begin(); hash_map<const char*,double,hash<const char*>,eqstr>::iterator chit; while(hit!=update.end()) { related_queries.insert(std::pair<double,std::string>((*hit).second,std::string((*hit).first))); chit = hit; ++hit; free_const((*chit).first); } }
void explore(Lit l, vector<Lit>& stack) { if (find(stack.begin(), stack.end(), l) != stack.end()) { // Found cycle // cerr << "Found cycle from " << l << endl; for (vector<Lit>::const_iterator i = find(stack.begin(), stack.end(), l); ++i != stack.end(); ) { addEquivalence(l, *i); addEquivalence(invert(l), invert(*i)); // cerr << ".. containing " << *i << endl; } // cerr << "End of cycle" << endl; } else if (find(stack.begin(), stack.end(), invert(l)) != stack.end()) { // We have not(l) -> l, so l is true addEquivalence(normalize(l), TRUE); addEquivalence(normalize(invert(l)), FALSE); // cerr << "Found known true literal " << l << endl; } else if (done.find(l) != done.end()) { // Nothing } else if (implications.find(l) == implications.end()) { // cerr << "Found pure literal " << l << endl; } else { done.insert(l); stack.push_back(l); for (size_t i = 0; i < implications[l].size(); ++i) { explore(implications[l][i], stack); } stack.pop_back(); } }
void replace(string user){ double min = 1000; int minI = -1; for (int i = 0; i < net[user].size(); i++){ double tmp = sim(user, net[user][i]); if (min > tmp){ min = tmp; minI = i; } } double max = -10000; string kk; hash_map<string, vector<Node>*>::iterator it; for (it = mylog.begin(); it != mylog.end(); it++){ if (in(it->first, net[user])){ continue; } double tmp = sim(user, it->first); if (max < tmp){ max = tmp; kk = it->first; } } if (min < max){ net[user][minI] = kk; } }
static double GetHatFit( // args same as non CACHE version, see below int x, // in int y, // in const HatFit hatfit) // in { const double* descbuf = NULL; // the HAT descriptor // for max cache hit rate, x and y should divisible by HAT_SEARCH_RESOL CV_DbgAssert(x % HAT_SEARCH_RESOL == 0); CV_DbgAssert(y % HAT_SEARCH_RESOL == 0); if (TRACE_CACHE) ncalls_g++; const unsigned key(Key(x, y)); #pragma omp critical // prevent OpenMP concurrent access to cache_g { hash_map<unsigned, VEC>:: const_iterator it(cache_g.find(key)); if (it != cache_g.end()) // in cache? { descbuf = Buf(it->second); // use cached descriptor if (TRACE_CACHE) nhits_g++; } } if (descbuf == NULL) // descriptor not in cache? { const VEC desc(hat_g.Desc_(x, y)); #pragma omp critical // prevent OpenMP concurrent access to cache_g cache_g[key] = desc; // remember descriptor for possible re-use descbuf = Buf(desc); } return hatfit(descbuf); }
Value VarExpression::Compute(const hash_map<string, Value>& vars) const { if (vars.find(name) == vars.end()) throw UnknownIdentifierException(name); return vars.find(name)->second; }
void UpdateBest(string& str, int& best) { if(f.find(str)!=f.end()) { best=max(best,f[str]); } }
void read_words(const string filename) { assert(!open_word_list); ifstream fin(filename.c_str()); assert(fin.is_open()); _all_words.clear(); word_list.clear(); word_list.push_back(""); assert(word_list.at(NO_WORD) == ""); word_map.clear(); word_map[""] = NO_WORD; // FIXME: Don't use [] operator unsigned i; string word; while(!fin.eof()) { fin >> i >> ws >> word >> ws; word_list.push_back(word); assert(word_list.at(i) == word); word_map[word] = i; // FIXME: Don't use [] operator _all_words.push_back(i); // if (word == "*content*") _Word_CONTENT = i; } assert(word_list.size() == word_map.size()); cerr << "Read " << word_list.size()-1 << " words from '" << filename << "'\n"; fin.close(); open_word_list = true; }
bool process(state* astate, queue<state*>& bfsq) { if(astate->clocks == ten9) { return print(astate); } for(int i=0; i<9; i++) { newstate.set(astate); newstate.inc(config[i]); //cout<<"trying state: "<<newstates[i].getnum()<<", foundsz="<<answers.size()<<endl; if(visited.find(newstate.clocks) == visited.end()) { state *ns = new state(); ns->clocks = newstate.clocks; ns->prevop = i+1; ns->prevstate = astate; bfsq.push(ns); visited[ns->clocks] = true; nobj++; } } return true; }
void print_tree(const ast &tree, hash_map<expr*,symbol> &cnames, std::ostream &out){ hash_map<expr*,symbol>::iterator foo = cnames.find(to_expr(tree.raw())); if(foo != cnames.end()){ symbol nm = foo->second; if (is_smt2_quoted_symbol(nm)) { out << mk_smt2_quoted_symbol(nm); } else { out << nm; } } else if(op(tree) == And){ out << "(and"; int nargs = num_args(tree); for(int i = 0; i < nargs; i++){ out << " "; print_tree(arg(tree,i), cnames, out); } out << ")"; } else if(op(tree) == Interp){ out << "(interp "; print_tree(arg(tree,0), cnames, out); out << ")"; } else throw iz3pp_bad_tree(); }
/* * Insert key in map * Returns A pointer to the hash_entry corresponding to key * Null in case of error * status is set to: * The position of hash_entry in case of success * One of the following in case of errors: * MOCA_HASHMAP_ALREADY_IN_MAP * MOCA_HASHMAP_FULL * MOCA_HASHMAP_ERROR */ hash_entry Moca_AddToMap(hash_map map, hash_entry e, int *status) { unsigned long h; int ind=0; unsigned int nextPos; if(!map) { *status=MOCA_HASHMAP_ERROR; return NULL; } if(map->nbentry==map->tableSize) { *status=MOCA_HASHMAP_FULL; return NULL; } //Do the insertion nextPos=Moca_FindNextAvailPosMap(map); MOCA_DEBUG_PRINT("Moca inserting %p ind %d/%lu total %d\n", e->key,nextPos,map->tableSize, map->nbentry); if(nextPos >= map->tableSize) { *status=MOCA_HASHMAP_ERROR; Moca_Panic("Moca hashmap BUG in AddToMap"); return NULL; } //Update the link h=hash_ptr(e->key, map->hash_bits); ind=map->hashs[h]; //TODO refactor here if(ind<0) { memcpy(tableElt(map,nextPos),e,map->elt_size); tableElt(map,nextPos)->next=MOCA_HASHMAP_END; map->hashs[h]=nextPos; } else { while(map->comp(tableElt(map,ind),e)!=0 && tableElt(map,ind)->next>=0) ind=tableElt(map,ind)->next; if(map->comp(tableElt(map,ind),e)==0) { MOCA_DEBUG_PRINT("Moca %p already in map %p\n", e->key, map); *status=MOCA_HASHMAP_ALREADY_IN_MAP; //This seems useless tableElt(map,nextPos)->key=NULL; return tableElt(map,ind); } MOCA_DEBUG_PRINT("Moca collision in map %p key %p\n", map, e->key); //TODO: Use Memcpy memcpy(tableElt(map,nextPos),e,map->elt_size); tableElt(map,nextPos)->next=MOCA_HASHMAP_END; tableElt(map,ind)->next=nextPos; } ++map->nbentry; MOCA_DEBUG_PRINT("Moca Inserted %p in map %p\n", e->key, map); *status=nextPos; return tableElt(map,nextPos); }
void DumpDOT( char *Filename, multimap <OperandPosition,OperandPosition,OperandPositionCompareTrait> &InstructionMap, hash_map <ea_t,insn_t> &InstructionHash ) { HANDLE hFile=OpenLogFile(Filename); //InstructionMap //InstructionHash WriteToLogFile(hFile,"digraph g {\r\n\ graph [\r\n\ rankdir = \"TB\"\r\n\ ];\r\n\ node [\r\n\ fontsize = \"12\"\r\n\ ];\r\n\ edge [\r\n\ ];\r\n"); //shape = \"ellipse\"\r\n\ hash_map <ea_t,insn_t>::iterator InstructionHashIter; //Write Node Data for(InstructionHashIter=InstructionHash.begin();InstructionHashIter!=InstructionHash.end();InstructionHashIter++) { ea_t address=InstructionHashIter->first; char op_buffer[100]={0,}; ua_mnem(address,op_buffer,sizeof(op_buffer)); WriteToLogFile(hFile,"\"%X\" [\r\n\tlabel=\"%s",address,op_buffer); for(int i=0;i<UA_MAXOP;i++) { if(InstructionHashIter->second.Operands[i].type>0) { char operand_str[MAXSTR]={0,}; ua_outop(address,operand_str,sizeof(operand_str)-1,i); tag_remove(operand_str,operand_str,0); char *escaped_operand_str=EscapeString(operand_str); if(escaped_operand_str) { WriteToLogFile(hFile,"|<f%u>%s",i,escaped_operand_str); free(escaped_operand_str); } } } WriteToLogFile(hFile,"\"\r\n\tshape=\"record\"\r\n];\r\n\r\n"); } multimap <OperandPosition,OperandPosition,OperandPositionCompareTrait>::iterator InstructionMapIter; for(InstructionMapIter=InstructionMap.begin();InstructionMapIter!=InstructionMap.end();InstructionMapIter++) { WriteToLogFile(hFile,"\"%X\":f%u -> \"%X\":f%u\r\n", InstructionMapIter->first.Address, InstructionMapIter->first.Index, InstructionMapIter->second.Address, InstructionMapIter->second.Index); } CloseLogFile(hFile); }
Lit normalize(Lit a) { while (true) { hash_map<Lit, Lit>::const_iterator i = equivalences.find(a); if (i == equivalences.end()) break; a = i->second; } return a; }
Field VarExpression::GetSuitableField(const string& fieldName, const hash_map<string, Field>& v) const { if (v.find(name) == v.end()) throw UnknownIdentifierException(name); Field f = v.find(name)->second; return Field(fieldName.c_str(), f.type, f.size); }
void ReplicateInfoMessage::set_replicating_map(const hash_map<uint32_t, ReplBlock*>& src) { hash_map<uint32_t, ReplBlock*>::const_iterator it = src.begin(); for (; it != src.end(); ++it) { replicating_map_.insert(REPL_BLOCK_MAP::value_type(it->first, *(it->second))); } }
void countPairs(vector<Event*> &events){ for( vector<Event*>::iterator fst = events.begin(); fst != events.end(); fst++){ for( vector<Event*>::iterator snd = fst; snd != events.end() && snd - fst < THRESHOLD; snd++){ if( (*fst)->thread != (*snd)->thread ){ string fString = (*fst)->btString(); string sString = (*snd)->btString(); bool found = false; pthread_rwlock_rdlock( &histoLock ); if( histo.find( fString ) != histo.end() ){ if( histo[fString].find( sString ) != histo[fString].end() ){ found = true; histo[fString][sString][snd-fst]++; } } pthread_rwlock_unlock( &histoLock ); if( !found ){ pthread_rwlock_wrlock( &histoLock ); if( (histo.find( fString )) == histo.end() ){ histo.insert( std::pair<string, hash_map<string, vector<unsigned long> > >(fString, hash_map<string, vector<unsigned long> >())); } if( histo[fString].find(sString) == histo[fString].end() ){ histo[fString].insert(std::pair<string, vector<unsigned long> >(sString, vector<unsigned long>())); for(int i = 0; i < THRESHOLD; i++ ){ histo[fString][sString].push_back(0); } } assert(snd - fst < THRESHOLD); histo[fString][sString][snd-fst]++; pthread_rwlock_unlock( &histoLock ); } } } } }
locale _Catalog_locale_map::lookup(int key) const { if (M) { hash_map<int, locale>::iterator i = M->find(key); return i != M->end() ? (*i).second : locale::classic(); } else return locale::classic(); }
//добавить переменную в таблицу символов static void add_var(const string& name) { if (table.find(name)!= table.end()) error("duplicate variable"); else{ if (table.size() > SIZEVART) error("too many variables"); else table[name] = 0.0; } }
int addColor(const string & s) { hash_map<string, int>::iterator found = colorMap.find(s); if (found == colorMap.end()) { colorMap[s] = totalColors; return totalColors++; } else { return found->second; } }
void AdGroupPool::CheckIfHaveCreative(hash_map<Ice::Long, AdGroupPtr> & group_pool) { for (hash_map<Ice::Long, AdGroupPtr>::iterator git = group_pool.begin(); git != group_pool.end();) { if (!git->second->HasCreatives()) { // MCE_DEBUG("AdGroupPool::Init --> because obj->HasCreatives is false so erase it groupid = " << git->first); group_pool.erase(git++); } else{ ++git; } } }
inline void* unparseAndIntern(SgAsmExpression* e) { hash_map<SgAsmExpression*, void*>::const_iterator i = unparseAndInternTable.find(e); if (i == unparseAndInternTable.end()) { void* sPtr = intern(unparseX86Expression(e, NULL)); unparseAndInternTable.insert(std::make_pair(e, sPtr)); return sPtr; } else { return i->second; } }
// static. float oskmeans::enorm(const hash_map<uint32_t,float,id_hash_uint> &p) { float enorm = 0.0; hash_map<uint32_t,float,id_hash_uint>::const_iterator hit = p.begin(); while (hit!=p.end()) { enorm += (*hit).second*(*hit).second; ++hit; } return sqrt(enorm); }
double sim(string follow, string leader){ if (simMatrix.find(follow + leader) != simMatrix.end()){ return simMatrix[follow + leader]; } double t1 = getNum(follow, leader) - getNum2(follow, leader); double t2 = mylog[leader]->size(); double t3 = 1 - 1 / sqrt(mylog[leader]->size()); double res = t1 / t2*t3; simMatrix[follow + leader] = res; return res; }
//在哈希词典中查找词,若找到,则返回,否则返回 int CDictionary::FindWord(string w) { if (wordhash.find(w) != wordhash.end()) { return 1; } else { return 0; } }
int YglIsCached(u32 addr, YglCache * c ) { hash_map< u32 , YglCache >::iterator pos = g_TexHash.find(addr); if( pos == g_TexHash.end() ) { return 0; } c->x=pos->second.x; c->y=pos->second.y; return 1; }
void mapSave(string fileName, hash_map<int, int> &feature2kernel) { ofstream outfile; outfile.open(fileName); for (hash_map<int, int>::iterator iter = feature2kernel.begin(); iter != feature2kernel.end(); iter++) { outfile << iter->first << " " << iter->second << endl; } outfile.close(); }
void _Catalog_locale_map::insert(int key, const locale& L) { // Don't bother to do anything unless we're using a non-default ctype facet try { typedef ctype<wchar_t> wctype; if (typeid(use_facet<wctype>(L)) != typeid(const wctype&)) { if (!M) M = new hash_map<int, locale>; if (M->find(key) == M->end()) M->insert(pair<const int, locale>(key, L)); } } catch(...) {} }
/*************************************************************************** * Set symbol information ***************************************************************************/ bool CCilVm::setSymbolInformation( hash_map<wstring, CG_SYMBOL_INFORMATION>& symbolinfo) { if( m_status != VM_EXECUTE_INITIALIZING ) return false; hash_map<wstring, CG_SYMBOL_INFORMATION>::iterator it = symbolinfo.begin(); pair<wstring, CG_SYMBOL_INFORMATION> pair; for( ; it != symbolinfo.end(); ++it) { pair = *it; m_SymbolInfoPool[ pair.first ] = pair.second; } return true; }
/************************************************* * Function: * check_connect_timeout * Description: * 检测长时间没反应的网络连接,并关闭删除 * Input: * * Output: * * Others: * *************************************************/ void *check_connect_timeout(void* para) { hash_map<int, sockStruct>::iterator it_find; for(it_find = sock_map.begin(); it_find!=sock_map.end(); ++it_find){ if( time((time_t*)0) - (it_find->second).time > 120){ //时间更改 free((it_find->second).recvBuf); sock_map.erase(it_find); close(it_find->first); } } }
void InitHatLevData( // init the global HAT data needed for this pyr level const Image& img, // in int ilev) // in { if (ilev <= HAT_START_LEV) // we use HATs only at upper pyr levs { hat_g.Init_(img, PatchWidth(ilev)); #if CACHE if (TRACE_CACHE) // show results from previous run lprintf("[calls %d hitrate %.2f cachesize %d]\n", ncalls_g, double(nhits_g) / ncalls_g, cache_g.size()); cache_g.clear(); #endif } }