C++ hash_map::find方法代码示例

Value VarExpression::Compute(const hash_map<string, Value>& vars) const
{
	if (vars.find(name) == vars.end())
		throw UnknownIdentifierException(name);

	return vars.find(name)->second;
}

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 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 );

        }
         
      } 
      
    }
    
  }

}

void computeIDoms(vector<IFR_BasicBlock> &bblist, 
                  hash_map<ADDRINT, set<ADDRINT> > &dom, 
                  hash_map<ADDRINT, ADDRINT> &idom){

  for( vector<IFR_BasicBlock>::iterator bi = bblist.begin();
       bi != bblist.end();
       bi++
     ){

    for( set<ADDRINT>::iterator di = dom[bi->getEntryAddr()].begin();
         di != dom[bi->getEntryAddr()].end();
         di++
       ){
  
      if( *di == bi->getEntryAddr() ){ continue; }  //only strict dominators are considered
      bool iDom = true; 
      for( set<ADDRINT>::iterator odi = dom[bi->getEntryAddr()].begin();
           odi != dom[bi->getEntryAddr()].end();
           odi++
         ){

        if( *odi == bi->getEntryAddr() ){ continue; }  //bi-> is the one whose idom we're looking for
        if( *odi == *di ){ continue; }  //only strict dominators are considered

        /*If any other dominator in bi's dominator set is dominated by di, then
         *di can't be bi's iDom.
         */
        if( dom[ *odi ].find( *di ) != dom[ *odi ].end()){
          iDom = false;
        }

      }

      if( iDom ){
        assert( idom.find(bi->getEntryAddr()) == idom.end() );
        idom.insert( std::pair<ADDRINT, ADDRINT>(bi->getEntryAddr(), *di) );
      } 

    }

    if( idom.find(bi->getEntryAddr()) == idom.end() ){
      /*an immediate dominator of 0 means this node has no immediate dominator*/
      idom.insert( std::pair<ADDRINT, ADDRINT>(bi->getEntryAddr(), 0) );
    }

  }

}

int calc(char s[])
{
    len = strlen(s);
    Manacher(s,len);

    sum[0] = s[0];
    for (int i = 1; i < len; i++)
        sum[i] = sum[i-1]*muts+s[i];

    int res = 0;
    uint tmp;
    int nt = 0;
    hash.clear();
    //odd
    for (int i = 0; i < len; i++)
        if (Mp[i*2+2]%2 == 0)
        {
            int pl = Mp[i*2+2]/2;
            if (i+pl < nt || pl == 0)	continue;
            for (int j = i-pl+1; j <= i; j++)
            {
                tmp = gethashcode(j,i);
                if (hash.find(tmp,i-j+1) != -1)	break;
                hash.insert(tmp,i-j+1);
            }
            nt = i+pl;
        }
    res += hash.N;

    nt = 0;
    hash.clear();
    //even
    for (int i = 0; i < len; i++)
        if (Mp[i*2+3] > 1)
        {
            int pl = Mp[i*2+3]/2;
            if (i+pl < nt || pl == 0)	continue;
            for (int j = i-pl+1; j <= i; j++)
            {
                tmp = gethashcode(j,i);
                if (hash.find(tmp,i-j+1) != -1)	break;
                hash.insert(tmp,i-j+1);
            }
            nt = i+pl;
        }
    res += hash.N;
    return res;
}

  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();
  }

	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]);
			}
		}
	}

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 UpdateBest(string& str, int& best)
{
	if(f.find(str)!=f.end())
	{
		best=max(best,f[str]);
	}
}

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);
}

  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();
  }
}

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;
}

void ComputeTFIDFWeights(string directory,vector<data*>& Y,hash_map<string,indx>& X)
{
	string temp;
	string tempx;
	hash_map<string,indx>::iterator ter;
	std::ofstream ofs(directory+"train.dat");
	std::ofstream ofss(directory+"predict\\test.dat");
	double Num;
	double DeNum;
	for(int i=0;i<Y.size();i++)
	{
		if(Y[i]->label==1)
			temp.append("+1");
		else if(Y[i]->label==-1)
			temp.append("-1");
		else
			temp.append("0");
		tempx.append(" # ");
		for(set<attribute,attribute>::iterator it=Y[i]->features.begin();it!=Y[i]->features.end();it++)
		{
			temp.append(" ");
			if((ter=X.find(it->feature))!=X.end() && ter->second.DF>MIN_DF_FOR_FEATURE)
			{
			temp.append(IntToString(it->index));
			temp.append(":");
			Num=(double)Y.size();
			DeNum=(ter=X.find(it->feature))==X.end()?0.0:(double)ter->second.DF;
			double IDF=log(Num/DeNum);
			temp.append(DoubleToString(it->TF*IDF));
			}
			tempx.append(it->feature);
			tempx.append(",");
		}
		if(*(tempx.end()-1)==',')
		tempx.erase(tempx.end()-1);
		if(Y[i]->label==0)
		ofss<<temp<<tempx<<"\n";
		else
		ofs<<temp<<tempx<<"\n";
		temp.clear();
		tempx.clear();

	}
	ofs.close();
	ofss.close();
}

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;
  }
}