int insertElement(char * element,int N) { //! insert an element //! returns the number of collisions which occurred before the element was inserted int bucket,nrofcol=0; bucket=hashFunction(element,nrofcol); while(nrofcol<size) { if(hashTable[bucket]==NULL) { hashTable[bucket]=element; return nrofcol; } nrofcol++; bucket++; if(nrofcol>nrmax) nrmax=nrofcol; } if(getFillFactor()>MAX_FILL_FACTOR) resizeHashTable(N); return 0; }
int main() { int N = 100; char ** content = readFromFile(N); printContentToConsole(content,N); initHashTable(N); int MAX=0; int i=0,resizeTable=0; while(i<N) { int x=hashFunction(*content,i); i++; if (insertElement(content[i],x)==-1) { i=0; resizeTable++; } } totalNrOfCollisions=0; for(i=0;i<N;i++) { totalNrOfCollisions+=nrOfCollisions[i]; printf("\nelement %d : %d collisions",i,nrOfCollisions[i]); if (MAX<nrOfCollisions[i]) MAX=nrOfCollisions[i]; } printf("\nthe maximum nr of collisions is %d", MAX); printf("\nthe total number of collisions is %d", totalNrOfCollisions); printf("\nthe number of resizes is %d",resizeTable); return 0; }
int insertValue(int key, HashTable *numbers){ int h, i; h = hashFunction(key, numbers->size); i = 0; while(numbers->table[h].key != 0 && (i < numbers->size)){ if(numbers->table[h].key == key){ return -1; } h = (h + 1) % numbers->size; } if(numbers->table[h].key == 0){ numbers->table[h].key = key; numbers->table[h].value = h; return 0; } return 0; }
void buildTable(HashTable *hash, char *string) { int index = hashFunction(string, hash->size); addListElement(hash->table[index], string); }
size_t hashFunction( const YourString &key ) { return hashFunction( key.Value() ); }
size_t hashFunction( const std::string &key ) { return hashFunction( key.c_str() ); }
int getKeyFromFile(char const* file) { return ftok(file, hashFunction(file)); }
int main(int argc, char* argv[]) { int idx; idx = hashFunction("hello"); insert(idx, "hello"); idx = hashFunction("apple"); insert(idx, "apple"); idx = hashFunction("cat"); insert(idx, "cat"); idx = hashFunction("caterpiller"); insert(idx, "caterpiller"); idx = hashFunction("and"); insert(idx, "and"); idx = hashFunction("ant"); insert(idx, "ant"); idx = hashFunction("ball"); insert(idx, "ball"); idx = hashFunction("airplane"); insert(idx, "airplane"); idx = hashFunction("airplane"); insert(idx, "airplane"); idx = hashFunction("zoo"); insert(idx, "zoo"); idx = hashFunction("cat"); insert(idx, "cat"); for (int i = 0; i < SIZE; i++) { if (hashtable[i] != NULL) { printf("This is the %dth index\n", i); int counter = 0; node* temp = hashtable[i]; while (temp != NULL) { printf("The list element at %d is %s\n", counter, temp->word); temp = temp->next; counter ++; } } } }
vector<int> getCandidates(HashParam hp, vector<float> sp, const Mat& proj) { vector<int> candidates; vector<int> frequency; vector<int> hashLocation(hp.bucketNumber, -1); vector<int> cursors(hp.bucketNumber, 0); vector<int> itemNumber(hp.bucketNumber, 0); for(int bucket = 0; bucket < hp.bucketNumber; bucket ++) { hashLocation[bucket] = hashFunction(hp, sp, proj.row(bucket)); } candidates.clear(); frequency.clear(); for(int bucket = 0; bucket < hp.bucketNumber; bucket ++) { cursors[bucket] = 0; itemNumber[bucket] = hp.bucketInfo[bucket][hashLocation[bucket]].size(); } int candidateSize = 0; int lastElement = -1; //printf("start...get candidtate ...\n"); while(1) { bool changeFlag = false; int min; int minBucket; for(int i = 0; i < hp.bucketNumber; i ++) { if(cursors[i] < itemNumber[i]) { changeFlag = true; min = hp.bucketInfo[i][hashLocation[i]][cursors[i]]; minBucket = i; break; } } if(!changeFlag) break; for(int i = minBucket + 1; i < hp.bucketNumber; i ++) { if(cursors[i] < itemNumber[i] && hp.bucketInfo[i][hashLocation[i]][cursors[i]] < min) { min = hp.bucketInfo[i][hashLocation[i]][cursors[i]]; minBucket = i; } } if(min == lastElement) { frequency[candidateSize-1] ++; } else { candidates.push_back(min); frequency.push_back(1); candidateSize ++; lastElement = min; } cursors[minBucket] ++; } //printf("end...get candidtate ...\n"); return candidates; }
/*implements A* algorithm*/ tree astar(int x, int y, int d, int heuristic){ char a = 'X';//X simbolize that no action was taken to get there tree t, t1, t2; char **mat1, **mat2; int i, j; int level; double f; queue_vector aux; int k; //copy the starting matrix mat1 = newMatrix(); for(i = 0; i < n; i++){ for(j = 0; j < m; j++) mat1[i][j] = w[i][j]; } t1 = insertTree(NULL, d, x, y, mat1, a, 0); t = t1; //compute the f value according to the heuristic f = computeHeuristic(x, y, 0, heuristic); insertQueue(t1, f); while(n_queue > 0){ //remove the first element of the queue removeQueue(&aux.t, &aux.f); t1 = aux.t; d = t1 -> dirt; mat1 = t1 -> mat; a = t1 -> action; x = t1 -> x; y = t1 -> y; level = t1 -> level; //increments the number of nodes expanded expanded++; //adds into the queue if(y != 0 && mat1[y-1][x] != '#'){ mat2 = newMatrix(); copyMatrix(mat1, mat2); a = mat1[y-1][x]; mat2[y-1][x] = '@'; mat2[y][x] = '_'; if(a == '*') k = d-1; else k = d; if(checkDuplicate(t, mat2, hashFunction(x, y-1), k) == 0){ //inserts in lowercase if there is dirt if(a == '*'){ removeListDirt(x, y-1); t2 = insertTree(t1, d-1, x, y-1, mat2, 'n', level + 1); if(d-1 == 0) return t2; } else t2 = insertTree(t1, d, x, y-1, mat2, 'N', level + 1); t1 -> N = t2; //compute the f value according to the heuristic f = computeHeuristic(x, y-1, level+1, heuristic); insertQueue(t2, f); generated++; } } if(y != n - 1 && mat1[y+1][x] != '#'){ mat2 = newMatrix(); copyMatrix(mat1, mat2); a = mat1[y+1][x]; mat2[y+1][x] = '@'; mat2[y][x] = '_'; if(a == '*') k = d-1; else k = d; if(checkDuplicate(t, mat2, hashFunction(x, y+1), k) == 0){ //inserts in lowercase if there is dirt if(a == '*'){ removeListDirt(x, y+1); t2 = insertTree(t1, d-1, x, y+1, mat2, 's', level + 1); if(d-1 == 0) return t2; } else t2 = insertTree(t1, d, x, y+1, mat2, 'S', level + 1); t1 -> S = t2; //compute the f value according to the heuristic f = computeHeuristic(x, y-1, level+1, heuristic); insertQueue(t2, f); generated++; } } if(x != 0 && mat1[y][x-1] != '#'){ mat2 = newMatrix(); copyMatrix(mat1, mat2); a = mat1[y][x-1]; mat2[y][x-1] = '@'; mat2[y][x] = '_'; if(a == '*') k = d-1; else k = d; if(checkDuplicate(t, mat2, hashFunction(x - 1, y), k) == 0){ //inserts in lowercase if there is dirt if(a == '*'){ removeListDirt(x-1, y); t2 = insertTree(t1, d-1, x-1, y, mat2, 'w', level + 1); if(d-1 == 0) return t2; } else t2 = insertTree(t1, d, x-1, y, mat2, 'W', level + 1); t1 -> W = t2; //compute the f value according to the heuristic f = computeHeuristic(x, y-1, level+1, heuristic); insertQueue(t2, f); generated++; } } if(x != m - 1 && mat1[y][x+1] != '#'){ mat2 = newMatrix(); copyMatrix(mat1, mat2); a = mat1[y][x+1]; mat2[y][x+1] = '@'; mat2[y][x] = '_'; if(a == '*') k = d-1; else k = d; if(checkDuplicate(t, mat2, hashFunction(x + 1, y), k) == 0){ //inserts in lowercase if there is dirt if(a == '*'){ removeListDirt(x+1, y); t2 = insertTree(t1, d-1, x+1, y, mat2, 'e', level + 1); if(d-1 == 0) return t2; } else t2 = insertTree(t1, d, x+1, y, mat2, 'E', level + 1); t1 -> E = t2; //compute the f value according to the heuristic f = computeHeuristic(x, y-1, level+1, heuristic); insertQueue(t2, f); generated++; } } orderQueue(); } return NULL; }
/* Insert an element into the hash table pH. The key is pKey,nKey ** and the data is "data". ** ** If no element exists with a matching key, then a new ** element is created. A copy of the key is made if the copyKey ** flag is set. NULL is returned. ** ** If another element already exists with the same key, then the ** new data replaces the old data and the old data is returned. ** The key is not copied in this instance. If a malloc fails, then ** the new data is returned and the hash table is unchanged. ** ** If the "data" parameter to this function is NULL, then the ** element corresponding to "key" is removed from the hash table. */ void *sqlite4Fts2HashInsert( fts2Hash *pH, /* The hash table to insert into */ const void *pKey, /* The key */ int nKey, /* Number of bytes in the key */ void *data /* The data */ ){ int hraw; /* Raw hash value of the key */ int h; /* the hash of the key modulo hash table size */ fts2HashElem *elem; /* Used to loop thru the element list */ fts2HashElem *new_elem; /* New element added to the pH */ int (*xHash)(const void*,int); /* The hash function */ assert( pH!=0 ); xHash = hashFunction(pH->keyClass); assert( xHash!=0 ); hraw = (*xHash)(pKey, nKey); assert( (pH->htsize & (pH->htsize-1))==0 ); h = hraw & (pH->htsize-1); elem = findElementGivenHash(pH,pKey,nKey,h); if( elem ){ void *old_data = elem->data; if( data==0 ){ removeElementGivenHash(pH,elem,h); }else{ elem->data = data; } return old_data; } if( data==0 ) return 0; new_elem = (fts2HashElem*)fts2HashMalloc( sizeof(fts2HashElem) ); if( new_elem==0 ) return data; if( pH->copyKey && pKey!=0 ){ new_elem->pKey = fts2HashMalloc( nKey ); if( new_elem->pKey==0 ){ fts2HashFree(new_elem); return data; } memcpy((void*)new_elem->pKey, pKey, nKey); }else{ new_elem->pKey = (void*)pKey; } new_elem->nKey = nKey; pH->count++; if( pH->htsize==0 ){ rehash(pH,8); if( pH->htsize==0 ){ pH->count = 0; fts2HashFree(new_elem); return data; } } if( pH->count > pH->htsize ){ rehash(pH,pH->htsize*2); } assert( pH->htsize>0 ); assert( (pH->htsize & (pH->htsize-1))==0 ); h = hraw & (pH->htsize-1); insertElement(pH, &pH->ht[h], new_elem); new_elem->data = data; return 0; }
bool MyHash::Search (int x, int *probes) { int b=hashFunction(x,probes); //edopismos theshs gia to x if(isEmptyTable[b] || hashTable[b]!=x) return false; else return true; }
int main() { node *Table[MAX]; clearTable(Table); int a[MAX]; char *str; /*char in; char input[CHARS];*/ int i, j; double t; clock_t t1,t2; t1=clock(); for (j=0;j<MAX;j++) { a[j]=0; } for (j=0; j<2000; j++) { str=randstring(CHARS); insertValue(Table[hashFunction(str)], str); a[hashFunction(str)]++; } t2=clock(); t=(double)(t2-t1); printf ("The insertion of 2000 elements took %f seconds.", &t); printf ("\n"); for (j=0; j<MAX; j++) { printf ("%d ", a[j]); } /*while(1) { printf("(I)nsert\n(S)earch\n(L)ist all\n\n"); printf(" > "); scanf("%d",&in); switch(in) { case 1: printf("\tInserting: \n"); printf("\t > "); scanf("%s",input); Table[hashFunction(input)] = insertValue(Table[hashFunction(input)],input); break; case 2: printf("\tSearching value: \n"); printf("\t > "); scanf("%s", &input); if (hasValue(Table[hashFunction(input)],input)) { printf("%s is in the table!\n",input); } else { printf("%s is not in the table!\n",input); } break; case 3: for (i = 0; i < MAX; i++) { printf("[%d] ",i); printList(Table[i]); } break; default: break; return; } printf("_______________________________________________________\n"); }*/ }
void Tid_HashTable::insert(unsigned key, int offset) { unsigned hashed_key; hashed_key = hashFunction(key); int index = getBucketIndex(hashed_key, globalDepth); // koitaw ta globalDepth deksia bits gia na dw se poio index tha paw Bucket* tempBucket = bucketArray.get(index); if(tempBucket->empty == true) { tempBucket->insert(key, offset); } else { // An to key yparxei... if(tempBucket->key == key) { } else { unsigned bhashed_key = hashFunction(tempBucket->key); // Bucket hashed key while(getBucketIndex(bhashed_key, globalDepth) == getBucketIndex(hashed_key, globalDepth)) { doubleTableSize(); } int index2 = getBucketIndex(bhashed_key, globalDepth); index = getBucketIndex(hashed_key, globalDepth); if(tempBucket->localDepth == globalDepth -1) // Simple split otan uparxoun 2 pointers sto bucket { bucketArray.set(index, new Bucket(key, offset, globalDepth)); bucketArray.get(index2)->localDepth++; maxLocalCounter.set(maxLocalCounter.size()-1, maxLocalCounter.get(maxLocalCounter.size()-1)+2); } else // Split otan uparxoyn perissoteroi pointers sto bucket { unsigned local = bucketArray.get(index2)->localDepth; while(getBucketIndex(bhashed_key, local) == getBucketIndex(hashed_key, local)) // Oso to localDepth den einai arketo gia na diaxwristoun ta 2 kleidia, auksanetai kai diaxwrizontai ta buckets { if(getBucketIndex(bhashed_key, local+1) != getBucketIndex(hashed_key, local+1)) // An sto localDepth+1 diaxwrizetai vges apo loop break; local++; bucketArray.get(index2)->localDepth++; Bucket* newBucket = new Bucket(local); // Neo empty bucket unsigned oldindex = getBucketIndex(hashed_key, local); unsigned newindex; // Ypologismos tou bucket index poy tha diaforopoieitai sto bit pou orizei to neo local unsigned i = pow(2, local-1); if((oldindex & i) == 0) newindex = oldindex + i; else newindex = oldindex - i; unsigned dist = pow(2, local); for(unsigned i = newindex; i < size; i+=dist) // Metafora deiktwn tou index sto newBucket { bucketArray.set(i, newBucket); } } local++; Bucket* tempBucketnew = new Bucket(key, offset, local); bucketArray.set(index, tempBucketnew); bucketArray.get(index2)->localDepth++; unsigned toindex = getBucketIndex(hashed_key, local); // Ypologismos tou bucket index me to neo local depth unsigned dist = pow(2, local); // H apostash poy tha exei to bucket index me ton epomeno deikth poy tha deiksei sto new bucket for(unsigned i = toindex; i < size; i+=dist) // Metafora deiktwn tou indexTable sto tempBucketnew { bucketArray.set(i, tempBucketnew); } if(local == globalDepth) // An to local iso me global tote ta 2 bucket exoun localDepth = globalDepth kai to maxLocalCounter auksanetai kata 2 maxLocalCounter.set(maxLocalCounter.size()-1, maxLocalCounter.get(maxLocalCounter.size()-1)+2); } } } }
int DiskMultiMap::erase(const std::string& key, const std::string& value, const std::string& context) { int nodesDeleted = 0; DiskNode checkValues; BinaryFile::Offset bucketLoc = hashFunction(key); BinaryFile::Offset locofNode; BinaryFile::Offset none = 0; tracker.read(locofNode, bucketLoc /*+ sizeof(Header)*/); if (locofNode == 0) return 0; else{ BinaryFile::Offset current; BinaryFile::Offset previous; BinaryFile::Offset oldNext; DiskNode iter; Header h; tracker.read(h, 0); current = locofNode; tracker.read(iter, current); previous = 0; do{ tracker.read(iter, current); tracker.read(h,0); oldNext = iter.next;//why does this not return 0? if (iter.key == key && iter.value == value && iter.context == context) { std::cerr << "Erasing node at location: " << current << std::endl; if (previous == 0) //the first one after the bucket { BinaryFile::Offset newLocofNode = iter.next; tracker.write(newLocofNode, bucketLoc/* + sizeof(Header)*/); } else { DiskNode previousNewLink; tracker.read(previousNewLink, previous); previousNewLink.next = iter.next; tracker.write(previousNewLink, previous); } //next pointer on the deleted node?? if (h.freeList == 0) { h.freeList = current; iter.next = none; tracker.write(iter, current); tracker.write(h,0); } else{ iter.next = h.freeList; h.freeList = current; tracker.write(iter, current); tracker.write(h,0); } if (previous !=0) previous = current; current = oldNext; nodesDeleted++; } else{ previous = current; current = oldNext; } }while(current != 0); } return nodesDeleted; }
unsigned int IdHash::getTabId(const unsigned & id) const { return readAt(hashFunction(id),id); }
//proj:each row represent which dimensions should projection in this hash,different row represent different bucket void meanshiftCluster(const Mat& feature, Mat& convexPoints) { printf("start to meanshift point...\n"); time_t startTime = time(0); printf("start to compute the convex point for every point ...\n"); int nl = feature.rows; int nc = feature.cols; printf("nl: %d, nc: %d.\n", nl, nc); convexPoints.create(nl, nc, CV_32FC1); //set params; MeanShiftParam mp; setMeanShiftParams(mp); #ifdef LSH_NEIGHBOR HashParam hp; setHashParam(hp, nl, nc); Mat proj; #ifdef LOAD_HASHINFO_FROM_FILE const char* hashFile = "./output/hashInfo.dat"; readHashInfo(hashFile, proj, hp.bucketInfo); for(int i = 0; i < hp.bucketNumber; i ++) { for(int j = 0; j < hp.projectionSize; j ++) { int t = proj.at<int>(i, j); if(t < 0 || t >= nc) printf("i: %d, j: %d, t: %d\n", i, j, t); } } #else proj.create(hp.bucketNumber, hp.projectionSize, CV_32SC1); boostSample(hp.bucketNumber, hp.projectionSize, proj, nc); HashAllItems(feature, proj, hp); const char* hashFile = "./output/hashInfo.dat"; saveHashInfo(hashFile, proj, hp.bucketInfo); #endif printf("bucketNumber: %d, projectionSize: %d.\n", hp.bucketNumber, hp.projectionSize); printf("bucket length: %d\n", hp.bucketLength); printHashParamInfo(hp); //mp.windowRadius = setWindow(hp, feature, proj); mp.windowRadius = 50.001144; mp.tinyNearestD = mp.windowRadius * 0.1; hp.votes = 2; #else boostSample(hp.bucketNumber, hp.projectionSize, proj, nc); #endif //end of set params; /********** set window **************/ int initialPoint; float demoninator; vector<float> molecular(nc, 0); vector<float> shiftVector(nc, 0); int inNeighbor; int iterations; float oldChange; float newChange; bool advanceConvexed; int advancedConvexedPoint; vector<int> candidates; vector<int> frequency; vector<int> hashLocation(hp.bucketNumber, -1); vector<int> cursors(hp.bucketNumber, 0); vector<int> itemNumber(hp.bucketNumber, 0); vector<float> closeness; printf("start to enter circles for every point ...\n"); for(int counts = 0; counts < nl; counts ++) { printf("the %d-th iterations ...\n", counts); initialPoint = counts; iterations = mp.maxIterations; advanceConvexed = false; for(int j = 0; j < nc; j ++) { shiftVector[j] = feature.at<float>(initialPoint, j); } while(iterations > 0) { iterations --; inNeighbor = 0; demoninator = 0; for(int j = 0; j < nc; j ++) { molecular[j] = 0; } #ifdef LSH_NEIGHBOR //hash the shift vector and get candidates for(int bucket = 0; bucket < hp.bucketNumber; bucket ++) { ////////////////////////////////////////////////////////// hashLocation[bucket] = hashFunction(hp, shiftVector, proj.row(bucket)); } candidates.clear(); frequency.clear(); for(int bucket = 0; bucket < hp.bucketNumber; bucket ++) { cursors[bucket] = 0; itemNumber[bucket] = hp.bucketInfo[bucket][hashLocation[bucket]].size(); } int candidateSize = 0; int lastElement = -1; while(1) { bool changeFlag = false; int min; int minBucket; for(int i = 0; i < hp.bucketNumber; i ++) { if(cursors[i] < itemNumber[i]) { changeFlag = true; min = hp.bucketInfo[i][hashLocation[i]][cursors[i]]; minBucket = i; break; } } if(!changeFlag) break; for(int i = minBucket + 1; i < hp.bucketNumber; i ++) { if(cursors[i] < itemNumber[i] && hp.bucketInfo[i][hashLocation[i]][cursors[i]] < min) { min = hp.bucketInfo[i][hashLocation[i]][cursors[i]]; minBucket = i; } } if(min == lastElement) { frequency[candidateSize-1] ++; } else { candidates.push_back(min); frequency.push_back(1); candidateSize ++; lastElement = min; } cursors[minBucket] ++; } candidatesNumber.push_back(candidateSize); //printf("tag1\n"); //filter the candidates; int statisticalFilted = 0; int size = candidateSize; /*closeness.clear(); closeness.resize(size, 0.0); for(int cc = 0; cc < size; cc ++) { int near = candidates[cc]; for(int bucket = 0; bucket < hp.bucketNumber; bucket ++) closeness[cc] += weight[bucket] * (hashLocation[bucket] - hp.hashInfo[near][bucket]) ** 2; if(closeness[cc] > mp.windowRadius) continue; if(counts > cc && closeness[cc] < mp.tinyNearestD) { advancedConvexedPoint = cc; advanceConvexed = true; float* curent_data = convexPoints.ptr<float>(counts); const float* convex_data = convexPoints.ptr<float>(cc); for(int j = 0; j < nc; j ++) curent_data[j] = convex_data[j]; break; } double temp = exp(0 - closeness[cc]); demoninator += temp; for(int j = 0; j < nc; j ++) { molecular[j] += temp * feature.at<float>(candidates[cc], j); } inNeighbor ++; }*/ for(int cc = 0; cc < size; cc ++) { if(frequency[cc] >= hp.votes) { statisticalFilted ++; float t = l2norm(shiftVector, feature.row(candidates[cc])); //indicate the cc point have convexed and the hash value vevy same //and their distance is very near, it's convex if(counts > cc && t < mp.tinyNearestD) { advancedConvexedPoint = cc; advanceConvexed = true; float* curent_data = convexPoints.ptr<float>(counts); const float* convex_data = convexPoints.ptr<float>(cc); for(int j = 0; j < nc; j ++) curent_data[j] = convex_data[j]; break; } if(t < mp.windowRadius) { double temp = exp(0 - t); demoninator += temp; for(int j = 0; j < nc; j ++) { molecular[j] += temp * feature.at<float>(candidates[cc], j); } inNeighbor ++; } } } printf("candidateSize: %d, statisticalFilted: %d, inNeighbor: %d\n", candidateSize, statisticalFilted, inNeighbor); neighborFileterNumber.push_back(statisticalFilted); //printf("tag2\n"); #else for(int i = 0; i < nl; i ++) { float t = l2norm(shiftVector, feature.row(i)); if(t < mp.tinyNearestD && counts > i) { advancedConvexedPoint = i; advanceConvexed = true; float* curent_data = convexPoints.ptr<float>(counts); const float* convex_data = convexPoints.ptr<float>(i); for(int j = 0; j < nc; j ++) curent_data[j] = convex_data[j]; break; } if(t < windowRadius) { double temp = exp(0 - t); demoninator += temp; for(int j = 0; j < nc; j ++) { molecular[j] += temp * feature.at<float>(i, j); } inNeighbor ++; } } #endif if(inNeighbor == 0) { printf("neighbor: 0\n"); advanceConvexed = true; advancedConvexedPoint = counts; float* curent_data = convexPoints.ptr<float>(counts); const float* convex_data = feature.ptr<float>(advancedConvexedPoint); for(int j = 0; j < nc; j ++) curent_data[j] = convex_data[j]; break; } if(advanceConvexed) break; demoninator = 1.0/demoninator; for(int j = 0; j < nc; j ++) { molecular[j] = demoninator * molecular[j]; } //printf("tag3\n "); newChange = l2norm(shiftVector, molecular); convexTrend.push_back(newChange); if(newChange / oldChange < mp.epsilon) break; oldChange = newChange; shiftVector = molecular; //printf("tag4\n "); } convexTrend.push_back(-1);//seprate by -1 iters.push_back(mp.maxIterations - iterations); if(!advanceConvexed) { float* data = convexPoints.ptr<float>(counts); for(int j = 0; j < nc; j ++) data[j] = shiftVector[j]; } } string writer = "./output/convex.dat"; MatrixDataIo mdi(writer.c_str(), true, convexPoints); #ifdef LSH_NEIGHBOR printf("destroy the bucket info ...\n"); destroyBucket(hp); #endif //compute used time { time_t endTime = time(0); int totalUsed = endTime - startTime; //comparedTime[1] = totalUsed; shiftTime = totalUsed; printf("meanshift LSH: %d\n", totalUsed); } programPause(); printf("exit meanshift clustering...\n"); }
void SlaveMapper::createMapping(int processID, int numberOfProcesses) { int numberOfReceivedTriples = 0; std::set<int> visitedTriples; std::tr1::hash<std::string> hashFunction; char *message1Master2Slaves = (char*)malloc(GlobalConstants::MAX_CHARS_PER_LINE * sizeof(char)); int message2All2Slave[4], message2AllToSlaveResult[4]; std::string separationSymbol = MappingConfigurationFileManager::getInstance()->getSeparationSymbol(); std::string subject, predicate, object, line, triple, tripleReverse; int designedProcess, hashSubj, hashPred, hashObj, hashTriple, hashTripleReverse; while (true) { MPI_Bcast(message1Master2Slaves, GlobalConstants::MAX_CHARS_PER_LINE, MPI_CHAR, GlobalConstants::MASTER, MPI_COMM_WORLD); line.assign(message1Master2Slaves); if (line.find(INPUT_FILE_OVER) != line.npos) { break; } subject = line.substr(0, line.find(separationSymbol)); line = line.erase(0, subject.length() + separationSymbol.length()); predicate = line.substr(0, line.find(separationSymbol)); line = line.erase(0, predicate.length() + separationSymbol.length()); object = line.substr(0, line.find(separationSymbol)); triple = subject + separationSymbol + predicate + separationSymbol + object; tripleReverse = object + separationSymbol + predicate + separationSymbol + subject; hashSubj = hashFunction(subject); hashPred = hashFunction(predicate); hashObj = hashFunction(object); hashTriple = hashFunction(triple); hashTripleReverse = hashFunction(tripleReverse); designedProcess = ((numberOfReceivedTriples % (numberOfProcesses - 1)) + 1); message2All2Slave[0] = (visitedTriples.find(hashTriple) != visitedTriples.end() || visitedTriples.find(hashTripleReverse) != visitedTriples.end()) ? 1 : 0; message2All2Slave[1] = (mappingId2Node->find(hashSubj) != mappingId2Node->end()) ? 1 : 0; message2All2Slave[2] = (mappingId2Predicate->find(hashPred) != mappingId2Predicate->end()) ? 1 : 0; message2All2Slave[3] = (mappingId2Node->find(hashObj) != mappingId2Node->end()) ? 1 : 0; MPI_Reduce(message2All2Slave, message2AllToSlaveResult, 4, MPI_INT, MPI_MAX, designedProcess, MPI_COMM_WORLD); if (processID == designedProcess && message2AllToSlaveResult[0] == 0) { if (message2AllToSlaveResult[1] == 0) { mappingId2Node->operator [](hashSubj) = subject; } if (message2AllToSlaveResult[2] == 0) { mappingId2Predicate->operator [](hashPred) = predicate; } if (message2AllToSlaveResult[3] == 0) { mappingId2Node->operator [](hashObj) = object; } predicates->push_back(hashPred); objects->push_back(hashObj); if (mappingNode2Positions->find(hashSubj) == mappingNode2Positions->end()) { mappingNode2Positions->operator [](hashSubj) = *(new std::vector<int>); } mappingNode2Positions->operator [](hashSubj).push_back(predicates->size() - 1); predicates->push_back(hashPred); objects->push_back(hashSubj); if (mappingNode2Positions->find(hashObj) == mappingNode2Positions->end()) { mappingNode2Positions->operator [](hashObj) = *(new std::vector<int>); } mappingNode2Positions->operator [](hashObj).push_back(predicates->size() - 1); visitedTriples.insert(hashTriple); } numberOfReceivedTriples++; } visitedTriples.clear(); free(message1Master2Slaves); int numberOfNodes = mappingId2Node->size(), numberOfPredicates = mappingId2Predicate->size(), numberOfCorrectTriples = objects->size() / 2; MPI_Reduce(&numberOfNodes, NULL, 1, MPI_INT, MPI_SUM, GlobalConstants::MASTER, MPI_COMM_WORLD); MPI_Reduce(&numberOfPredicates, NULL, 1, MPI_INT, MPI_SUM, GlobalConstants::MASTER, MPI_COMM_WORLD); MPI_Reduce(&numberOfCorrectTriples, NULL, 1, MPI_INT, MPI_SUM, GlobalConstants::MASTER, MPI_COMM_WORLD); saveMapping(processID); }
linkedList_t* findInTable(symbol_t symbol, hashTable_ref table, int tableSize) { int index = hashFunction(symbol.text, tableSize); return find(symbol, table[index]); }
uint32_t PacaReader::HashString( const std::string& toHash ) const { std::hash<std::string> hashFunction; return hashFunction( toHash ); }