Beispiel #1
0
static INLINE
PAIR *createPair(CRDS *crds, PCODE pcode, CODE left, CODE right, uint f_pos)
{
  PAIR *pair = (PAIR *)malloc(sizeof(PAIR));
  uint h;
  PAIR *q;
  PQUE *p_que = crds->p_que[pcode];

  pair->pcode  = pcode;
  pair->left   = left;
  pair->right  = right;
  pair->freq   = 1;
  pair->f_pos  = pair->b_pos  = f_pos;
  pair->p_prev = pair->p_next = NULL;

  p_que->num_pairs++;

  if (p_que->num_pairs >= primes[p_que->h_num]) {
    rehash(crds, pcode);
  }

  h = hash_val(p_que->h_num, left, right);
  q = p_que->h_entry[h];
  p_que->h_entry[h] = pair;
  pair->h_next = q;

  insertPair(crds, pair);

  return pair;
}
Beispiel #2
0
 void init(){
    count = 0;
    while(!heap.empty()){
       heap.pop();
    }
    R_TreeNode<2,TupleId> root1 = t1->Root();
    R_TreeNode<2,TupleId> root2 = t2->Root();
    insertPair(root1,0, root2,0);
 }
Beispiel #3
0
void addPair(char* key, int value, hashTable* hTable) {
	hTable->loadFactor = insertPair(key, value, hTable->table, hTable->tableSize, hTable->loadFactor);

	if(hTable->loadFactor > hTable->maxLoad) {
		hTable->table = doubleSize(hTable->table, hTable->tableSize, hTable->loadFactor);
		hTable->loadFactor = hTable->loadFactor / 2;
		hTable->tableSize = hTable->tableSize * 2;
	}
}
Beispiel #4
0
static INLINE
void incrementPair(CRDS *crds, PAIR *target)
{
  PQUE *p_que = crds->p_que[target->pcode];
  if (target->freq >= p_que->p_max) {
    target->freq++;
    return;
  }
  removePair(crds, target);
  target->freq++;
  insertPair(crds, target);
}
Beispiel #5
0
		std::map< std::string, MB::StrVector > Resources::ResourceLists() 
		{
		  sf::Lock(this->mutex);
		  std::map<std::string,MB::StrVector> ResourceList;
			std::list<MB::Content::ID*>::iterator typeItr;
    
			for (typeItr = this->types.begin(); typeItr != this->types.end(); typeItr++)
			{
			  ID* resource = (*typeItr);
			  resource->Type();
      
			  std::pair<std::string,MB::StrVector> insertPair(resource->Type(),resource->List());
			  ResourceList.insert(insertPair);
			}
  
		  return ResourceList;
		}
Beispiel #6
0
static INLINE
void decrementPair(CRDS *crds, PAIR *target)
{
  PQUE *p_que = crds->p_que[target->pcode];

  if (target->freq > p_que->p_max) {
    target->freq--;
    return;
  }
  
  if (target->freq == 1) {
    //destructPair(crds, target);
  }
  else {
    removePair(crds, target);
    target->freq--;
    insertPair(crds, target);
  }
}
Beispiel #7
0
      Tuple* produceNextTuple(){
        while(!heap.empty() && !heap.top().isFinal()){
           closestPairEntry e = heap.top();
           heap.pop();
           if(e.final1()){
               R_TreeNode<2,TupleId> n2 = getNode2(e);
               for(int i=0;i<n2.EntryCount();i++){
                  if(n2.IsLeaf()){
                     R_TreeLeafEntry<2,TupleId> 
                        e2 = (R_TreeLeafEntry<2,TupleId>&)n2[i];
                     closestPairEntry entry(e,e2,e.getLevel2()+1);
                     if(!prune(entry)){
                        heap.push(entry);
                     }
                  } else {
                     R_TreeInternalEntry<2> e2 = (R_TreeInternalEntry<2>&)n2[i];
                     closestPairEntry entry(e,e2,e.getLevel2()+1);
                     if(!prune(entry)){
                        heap.push(entry);
                     }
                  }
               }
           }  else if(e.final2()){
               R_TreeNode<2,TupleId> n1 = getNode1(e);
               for(int i=0;i<n1.EntryCount();i++){
                  if(n1.IsLeaf()){
                     R_TreeLeafEntry<2,TupleId> 
                          e1 = (R_TreeLeafEntry<2,TupleId>&)n1[i];
                     closestPairEntry entry(e1,e.getLevel1()+1, e);
                     if(!prune(entry)){
                        heap.push(entry);
                     }
                  } else {
                     R_TreeInternalEntry<2> e1 = (R_TreeInternalEntry<2>&)n1[i];
                     closestPairEntry entry(e1,e.getLevel2()+1, e);
                     if(!prune(entry)){
                        heap.push(entry);
                     }
                  }
               }
           } else { // both are not final
               R_TreeNode<2,TupleId> n1 = getNode1(e);
               R_TreeNode<2,TupleId> n2 = getNode2(e);
               insertPair(n1,e.getLevel1()+1,n2,e.getLevel2()+1);
           }


        }
        if(heap.empty()){ // no more entries
           return 0;
        }
        closestPairEntry e = heap.top();
        heap.pop();
        TupleId tid1 = e.getTid1();
        TupleId tid2 = e.getTid2();
        Tuple* t1 = r1->GetTuple(tid1,true);
        Tuple* t2 = r2->GetTuple(tid2,true);
      
        if(t1==0 || t2==0){
           cerr << "TupleId stored in rtree not found" << endl;
           cerr << " computing closest pair canceled" << endl;
           count = k;
           return 0; 
        }
        Tuple* res = new Tuple(tt);
        Concat(t1,t2,res);
        t1->DeleteIfAllowed();
        t2->DeleteIfAllowed();
        count++;
        return res; 

      }
Beispiel #8
0
void NVMap::appendPairs(StringVector vector, char delim)
{
    for(StringVector::iterator itr = vector.begin(); itr != vector.end(); ++itr)
        insertPair(*itr, delim);
}