Merge pull request #6 from Sitaras/HyperCube2

Hypercube Neighbor Methods (NN,KNN,RangeSearch)

Author: giannhskp

Hypercube/hypercube.c

@@ -48,6 +48,20 @@ int binaryToDecimal(int n)
 
  return dec_value;
 }
+
+int binaryArrayToDecimal(int s[],int size)
+{
+ int n = 0;
+ int i;
+
+ for (i = 0; i < size; ++i) {
+ n <<= 1;
+ n += s[i];
+ }
+
+ return n;
+}
+
 /* H FUNCTIONS*/
 
 void generateH(h_function *hfun){
@@ -124,3 +138,178 @@ void deleteHyperCube(HyperCube hc){
  htDelete(hc->hypercube,1);
  free(hc);
 }
+
+
+void searchForHammingDistance(HyperCube hc,Vector v,int *v_index,int hammingDist,int startFrom,Vector *nearest,double *nearestDist,int *numOfSearched,int maxToSearch){
+ if(hammingDist<=0){
+ int new_index = binaryArrayToDecimal(v_index,k);
+ printf("** HAMMING INDEX =%d\n",new_index);
+ htFindNearestNeighborCube(hc->hypercube,new_index,v,nearest,nearestDist,d,numOfSearched,maxToSearch);
+ return;
+ }
+ for(int i=startFrom;i<k;i++){
+ v_index[i] = v_index[i]^1;
+ searchForHammingDistance(hc,v,v_index,hammingDist-1,i+1,nearest,nearestDist,numOfSearched,maxToSearch);
+ // search
+ v_index[i] = v_index[i]^1;
+ if((*numOfSearched)>=maxToSearch){
+ break;
+ }
+ }
+}
+
+void nearestNeigbor(HyperCube hc,Vector q,int hammingDist,int m){
+ printf("ABOUT TO SEARCH NEAREST NEIGHBOR FOR : ");
+ printVector(q);
+ Vector nearest=NULL;
+ double nearestDist=-1;
+ int index[k];
+ int searched = 0;
+ for(int i=0;i<k;i++){
+ int h_result = computeH(hc->h_functions[i],q);
+ int f_result = computeF(hc->f_funs[i],h_result);
+ index[i] = f_result;
+ }
+ int index_decimal = binaryArrayToDecimal(index,k);
+ printf("** INITIAL INDEX =%d\n",index_decimal);
+ htFindNearestNeighborCube(hc->hypercube,index_decimal,q,&nearest,&nearestDist,d,&searched,m);
+
+ for(int i=1;i<=hammingDist;i++){
+ if(searched>=m){
+ break;
+ }
+ searchForHammingDistance(hc,q,index,i,0,&nearest,&nearestDist,&searched,m);
+ }
+
+ if(nearestDist>=0 && nearest!=NULL){
+ printf("FOUND NEAREST NEIGHBOR ");
+ printVector(nearest);
+ printf("WITH DISTANCE = %f\n",nearestDist);
+ }else{
+ printf("- DID NOT FIND NEAREST NEIGHBOR\n");
+ }
+ printf("Checked: %d vectors\n",searched);
+}
+
+void searchForHammingDistanceKNN(HyperCube hc,Vector v,int *v_index,int hammingDist,int startFrom,Vector *nearest,double *nearestDist,int *numOfSearched,int maxToSearch,int knn){
+ if(hammingDist<=0){
+ int new_index = binaryArrayToDecimal(v_index,k);
+ printf("** HAMMING INDEX =%d\n",new_index);
+ htKFindNearestNeighborsCube(hc->hypercube,new_index,v,nearest,nearestDist,d,knn,numOfSearched,maxToSearch);
+ return;
+ }
+ for(int i=startFrom;i<k;i++){
+ v_index[i] = v_index[i]^1;
+ searchForHammingDistanceKNN(hc,v,v_index,hammingDist-1,i+1,nearest,nearestDist,numOfSearched,maxToSearch,knn);
+ // search
+ v_index[i] = v_index[i]^1;
+ if((*numOfSearched)>=maxToSearch){
+ break;
+ }
+ }
+}
+
+void kNearestNeigbors(HyperCube hc,Vector q,int knn,int hammingDist,int m){
+ printf("ABOUT TO SEARCH %d NEAREST NEIGHBORS FOR : ",knn);
+ printVector(q);
+ Vector nearest[knn];
+ double knearestDists[knn];
+ for (int i = 0; i < knn; i++){
+ knearestDists[i]=-1;
+ nearest[i]=NULL;
+ }
+
+ int index[k];
+ int searched = 0;
+ for(int i=0;i<k;i++){
+ int h_result = computeH(hc->h_functions[i],q);
+ int f_result = computeF(hc->f_funs[i],h_result);
+ index[i] = f_result;
+ }
+ int index_decimal = binaryArrayToDecimal(index,k);
+ printf("** INITIAL INDEX =%d\n",index_decimal);
+ htKFindNearestNeighborsCube(hc->hypercube,index_decimal,q,nearest,knearestDists,d,knn,&searched,m);
+
+ for(int i=1;i<=hammingDist;i++){
+ if(searched>=m){
+ break;
+ }
+ printf("--------*********--------------\n");
+ searchForHammingDistanceKNN(hc,q,index,i,0,nearest,knearestDists,&searched,m,knn);
+ }
+
+ int flag=1;
+ for (int i = knn-1; i >= 0; i--){
+ if (knearestDists[i] >= 0 && nearest[i] != NULL){
+ printf("FOUND %d NEAREST NEIGHBOR: ",i);
+ printVector(nearest[i]);
+ printf("WITH DISTANCE = %f\n", knearestDists[i]);
+ flag=0;
+ }
+ }
+ if(flag){
+ printf("- DID NOT FIND NEAREST NEIGHBOR\n");
+ }
+}
+
+
+
+void searchForHammingDistanceRadius(HyperCube hc,Vector v,int *v_index,int hammingDist,int startFrom,HashTable vecsInRadius,int *numOfSearched,int maxToSearch,int radius){
+ if(hammingDist<=0){
+ int new_index = binaryArrayToDecimal(v_index,k);
+ printf("** HAMMING INDEX =%d\n",new_index);
+ htFindNeighborsInRadiusCube(hc->hypercube,new_index,vecsInRadius,v,d,radius,numOfSearched,maxToSearch);
+ return;
+ }
+ for(int i=startFrom;i<k;i++){
+ v_index[i] = v_index[i]^1;
+ searchForHammingDistanceRadius(hc,v,v_index,hammingDist-1,i+1,vecsInRadius,numOfSearched,maxToSearch,radius);
+ // search
+ v_index[i] = v_index[i]^1;
+ if((*numOfSearched)>=maxToSearch){
+ break;
+ }
+ }
+}
+
+
+void radiusNeigbor(HyperCube hc,Vector q,double radius,int hammingDist,int m){
+ printf("ABOUT TO SEARCH FOR NEIGHBORS INSIDE RANGE : %f\n",radius);
+ HashTable vecsInRadius = htInitialize(100); // TODO: CHANGE SIZE
+
+ int index[k];
+ int searched = 0;
+ for(int i=0;i<k;i++){
+ int h_result = computeH(hc->h_functions[i],q);
+ int f_result = computeF(hc->f_funs[i],h_result);
+ index[i] = f_result;
+ }
+ int index_decimal = binaryArrayToDecimal(index,k);
+ printf("** INITIAL INDEX =%d\n",index_decimal);
+ htFindNeighborsInRadiusCube(hc->hypercube,index_decimal,vecsInRadius,q,d,radius,&searched,m);
+
+ for(int i=1;i<=hammingDist;i++){
+ if(searched>=m){
+ break;
+ }
+ printf("--------*********--------------\n");
+ searchForHammingDistanceRadius(hc,q,index,i,0,vecsInRadius,&searched,m,radius);
+ }
+
+ htRangePrint(vecsInRadius,q,d);
+
+ htDelete(vecsInRadius,0);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+///

Hypercube/hypercube.h

@@ -11,4 +11,10 @@ void printHyperCube(HyperCube );
 
 void deleteHyperCube(HyperCube );
 
+void nearestNeigbor(HyperCube ,Vector ,int ,int );
+
+void kNearestNeigbors(HyperCube ,Vector ,int ,int ,int );
+
+void radiusNeigbor(HyperCube ,Vector ,double ,int ,int );
+
 #endif

Hypercube/hypercube.h.gch

@@ -58,7 +58,7 @@ int hashFunction(const HashTable ht,Vector v,int d){ /* Hash function only used
  int c;
  for(int i=0;i<d;i++){
  c = coords[i];
- hash = ((hash * 33) + hash) + c; /* hash * 33 + c */
+ hash = (int)(((hash * 33) + hash) + c)% ht->buckets; /* hash * 33 + c */
  }
  return (((int)hash) % ht->buckets);
 }
@@ -113,3 +113,16 @@ void htKFindNearestNeighbors(HashTable ht,int index,Vector q,Vector *nearest,dou
 void htFindNeighborsInRadius(HashTable ht,int index,HashTable storeNeighbors,Vector q,int d,int id,int radius){
  listFindNeighborsInRadius(ht->table[index].head,storeNeighbors,q,d,id,radius);
 }
+
+
+void htFindNearestNeighborCube(HashTable ht,int index,Vector q,Vector *nearest,double *nearestDist,int d,int *numOfSearched,int maxToSearch){
+ listFindNearestNeighborCube(ht->table[index].head,q,nearest,nearestDist,d,numOfSearched,maxToSearch);
+}
+
+void htKFindNearestNeighborsCube(HashTable ht,int index,Vector q,Vector *nearest,double *nearestDist,int d,int k,int *numOfSearched,int maxToSearch){
+ listFindKNearestNeighborsCube(ht->table[index].head, q, nearest, nearestDist, d,k,numOfSearched,maxToSearch);
+}
+
+void htFindNeighborsInRadiusCube(HashTable ht,int index,HashTable storeNeighbors,Vector q,int d,int radius,int *numOfSearched,int maxToSearch){
+ listFindNeighborsInRadiusCube(ht->table[index].head,storeNeighbors,q,d,radius,numOfSearched,maxToSearch);
+}

hashTable/hashTable.c

@@ -19,4 +19,8 @@ void htKFindNearestNeighbors(HashTable, int, Vector, Vector *, double *, int ,in
 void htFindNeighborsInRadius(HashTable ,int ,HashTable ,Vector ,int ,int ,int );
 void htRangeInsert(HashTable , Vector ,int ,int );
 
+void htFindNearestNeighborCube(HashTable ,int ,Vector ,Vector *,double *,int ,int *,int );
+void htKFindNearestNeighborsCube(HashTable ,int ,Vector ,Vector *,double *,int ,int ,int *,int );
+void htFindNeighborsInRadiusCube(HashTable ,int ,HashTable ,Vector ,int ,int ,int *,int );
+
 #endif

hashTable/hashTable.h

@@ -97,7 +97,7 @@ void listPrint(List list){
  }
 }
 void listRangePrint(List list,Vector q,int d){
- if(list==NULL){  return;}
+ if(list==NULL){ return;}
  List temp=list;
  while(temp!=NULL){
  printf("Found vector: ");
@@ -142,6 +142,23 @@ void listFindNearestNeighbor(List list,Vector q,Vector *nearest,double *nearestD
  }
 }
 
+void listFindNearestNeighborCube(List list,Vector q,Vector *nearest,double *nearestDist,int d,int *numOfSearched,int maxToSearch){
+ if(list==NULL){ return;}
+ List temp=list;
+ while(temp!=NULL){
+ if((*numOfSearched)>=maxToSearch){
+ return;
+ }
+ double dist = distance_metric(temp->v,q,d);
+ if(dist<(*nearestDist) || (*nearestDist)<0){
+ (*nearestDist) = dist;
+ (*nearest) = temp->v;
+ }
+ (*numOfSearched)+=1;
+ temp=temp->next;
+ }
+}
+
 void swapDoubles(double *xp, double *yp)
 {
  double temp = *xp;
@@ -267,6 +284,58 @@ void listFindKNearestNeighbors(List list,Vector q,Vector *nearest,double *neares
  }
 }
 
+void listFindKNearestNeighborsCube(List list,Vector q,Vector *nearest,double *nearestDist,int d,int k,int *numOfSearched,int maxToSearch){
+ if(list==NULL){ return;}
+ List temp=list;
+ int filled=0;
+ while(temp!=NULL){
+ if((*numOfSearched)>=maxToSearch){
+ return;
+ }
+ int flag = 1;
+ int eq = 0;
+ int added=0;
+ double dist = distance_metric(temp->v,q,d);
+ (*numOfSearched) += 1;
+
+ int index=binarySearch(nearestDist,0,k-1,dist);
+ if(index!=-1 && nearest[index] != NULL && compareVectors(nearest[index], temp->v)){
+ eq = 1;
+ }
+ if (eq){
+ temp = temp->next;
+ continue;
+ }
+ if(!filled)
+ for (int i = 0; i < k; i++){
+ if(nearestDist[i]<0){
+ flag=0;
+ added=1;
+ nearestDist[i]=dist;
+ nearest[i]=temp->v;
+ break;
+ }
+ }
+
+ if (flag){
+ filled=1;
+ if(dist<nearestDist[0]){
+ added = 1;
+ nearestDist[0] = dist;
+ nearest[0] = temp->v;
+ }
+ }
+ if(added)
+ quickSort(nearestDist, nearest,0, k-1);
+ temp = temp->next;
+ }
+}
+
+
+
+
+
+
 void listFindNeighborsInRadius(List list,HashTable storeNeighbors,Vector q,int d,int id,int radius){
  if(list==NULL){ return;}
  List temp=list;
@@ -280,3 +349,19 @@ void listFindNeighborsInRadius(List list,HashTable storeNeighbors,Vector q,int d
  temp=temp->next;
  }
 }
+
+void listFindNeighborsInRadiusCube(List list,HashTable storeNeighbors,Vector q,int d,int radius,int *numOfSearched,int maxToSearch){
+ if(list==NULL){ return;}
+ List temp=list;
+ while(temp!=NULL){
+ if((*numOfSearched)>=maxToSearch){
+ return;
+ }
+ double dist = distance_metric(temp->v,q,d);
+ (*numOfSearched) += 1;
+ if(dist<=radius){
+ htRangeInsert(storeNeighbors,temp->v,temp->vector_ID,d);
+ }
+ temp=temp->next;
+ }
+}

hashTable/hashTable.h.gch

@@ -17,6 +17,9 @@ List listDelete(List ,int );
 
 void listFindNearestNeighbor(List ,Vector ,Vector *,double *,int ,int );
 void listFindKNearestNeighbors(List, Vector, Vector *, double *, int,int ,int );
-
 void listFindNeighborsInRadius(List ,HashTable ,Vector ,int ,int ,int );
+
+void listFindNearestNeighborCube(List ,Vector ,Vector *,double *,int ,int *,int );
+void listFindKNearestNeighborsCube(List ,Vector ,Vector *,double *,int ,int ,int *,int );
+void listFindNeighborsInRadiusCube(List ,HashTable ,Vector ,int ,int ,int *,int );
 #endif

hashTable/hashTableList/hashTableList.c

@@ -133,6 +133,15 @@ int main(int argc, char *argv[]) {
 
  printHyperCube(hc);
 
+ double vec[6] = {21, 3, 3, 18, 25, 11};
+ Vector vecTmp=initVector(vec);
+
+ nearestNeigbor(hc,vecTmp,1,4);
+ printf("================================================\n");
+ kNearestNeigbors(hc,vecTmp,3,3,100);
+ printf("================================================\n");
+ radiusNeigbor(hc,vecTmp,25,2,100);
+
  // printOptions(); // just printing the commands options for the user
  //
  //