updated text files
[RBC.git] / brute.cu
index ca55c54..037905c 100644 (file)
--- a/brute.cu
+++ b/brute.cu
@@ -1,3 +1,7 @@
+/* This file is part of the Random Ball Cover (RBC) library.
+ * (C) Copyright 2010, Lawrence Cayton [lcayton@tuebingen.mpg.de]
+ */
+
 #ifndef BRUTE_CU
 #define BRUTE_CU
 
 #include "brute.h"
 #include<stdio.h>
 #include<cuda.h>
+//#include<gsl/gsl_sort.h>
 
-void bruteRangeCount(matrix x, matrix q, real *ranges, int *cnts){
+void bruteRangeCount(matrix x, matrix q, real *ranges, unint *cnts){
   matrix dx, dq;
   real *dranges;
-  int *dcnts;
+  unint *dcnts;
   
   copyAndMove(&dx, &x);
   copyAndMove(&dq, &q);
 
-  cudaMalloc( (void**)&dranges, q.pr*sizeof(*dranges) );
+  checkErr( cudaMalloc( (void**)&dranges, q.pr*sizeof(*dranges) ) );
   cudaMemcpy( dranges, ranges, q.r*sizeof(*dranges), cudaMemcpyHostToDevice );
 
-  cudaMalloc( (void**)&dcnts, q.pr*sizeof(*dcnts) );
+  checkErr( cudaMalloc( (void**)&dcnts, q.pr*sizeof(*dcnts) ) );
   
   rangeCountWrap(dq, dx, dranges, dcnts);
   
@@ -35,39 +40,59 @@ void bruteRangeCount(matrix x, matrix q, real *ranges, int *cnts){
 }
 
 
-void bruteSearch(matrix x, matrix q, int *NNs){
+void bruteSearch(matrix x, matrix q, unint *NNs){
   real *dMins;
-  int *dMinIDs;
+  unint *dMinIDs;
   matrix dx, dq;
 
+  copyAndMove( &dx, &x );
+  copyAndMove( &dq, &q );
+
+  checkErr( cudaMalloc((void**)&dMins, q.pr*sizeof(*dMins)) );
+  checkErr( cudaMalloc((void**)&dMinIDs, q.pr*sizeof(*dMinIDs)) );
   
-  dx.r=x.r; dx.pr=x.pr; dx.c=x.c; dx.pc=x.pc; dx.ld=x.ld;
-  dq.r=q.r; dq.pr=q.pr; dq.c=q.c; dq.pc=q.pc; dq.ld=q.ld;
+  nnWrap( dq, dx, dMins, dMinIDs );
+
+  cudaMemcpy( NNs, dMinIDs, dq.r*sizeof(*NNs), cudaMemcpyDeviceToHost );
+  
+  cudaFree( dMins );
+  cudaFree( dMinIDs );
+  cudaFree( dx.mat );
+  cudaFree( dq.mat );
+}
 
-  cudaMalloc((void**)&dMins, q.pr*sizeof(*dMins));
-  cudaMalloc((void**)&dMinIDs, q.pr*sizeof(*dMinIDs));
-  cudaMalloc((void**)&dx.mat, dx.pr*dx.pc*sizeof(*dx.mat));
-  cudaMalloc((void**)&dq.mat, dq.pr*dq.pc*sizeof(*dq.mat));
 
-  cudaMemcpy(dx.mat,x.mat,x.pr*x.pc*sizeof(*dx.mat),cudaMemcpyHostToDevice);
-  cudaMemcpy(dq.mat,q.mat,q.pr*q.pc*sizeof(*dq.mat),cudaMemcpyHostToDevice);
+void bruteK(matrix x, matrix q, intMatrix NNs, matrix NNdists){
+  matrix dNNdists;
+  intMatrix dMinIDs;
+  matrix dx, dq;
+  
+  copyAndMove( &dx, &x );
+  copyAndMove( &dq, &q );
   
-  nnWrap(dq,dx,dMins,dMinIDs);
+  initMat( &dNNdists, q.r, KMAX );
+  checkErr( cudaMalloc((void**)&dNNdists.mat, sizeOfMatB(dNNdists) ) );
+
+  initIntMat( &dMinIDs, q.r, KMAX );
+  checkErr( cudaMalloc((void**)&dMinIDs.mat, sizeOfIntMatB(dMinIDs) ) );
+
+  knnWrap( dq, dx, dNNdists, dMinIDs );
 
-  cudaMemcpy(NNs,dMinIDs,dq.r*sizeof(*NNs),cudaMemcpyDeviceToHost);
+  cudaMemcpy( NNs.mat, dMinIDs.mat, sizeOfIntMatB(NNs), cudaMemcpyDeviceToHost );
+  cudaMemcpy( NNdists.mat, dNNdists.mat, sizeOfMatB(NNdists), cudaMemcpyDeviceToHost );
   
-  cudaFree(dMins);
-  cudaFree(dMinIDs);
-  cudaFree(dx.mat);
-  cudaFree(dq.mat);
+  cudaFree( dNNdists.mat );
+  cudaFree( dMinIDs.mat );
+  cudaFree( dx.mat );
+  cudaFree( dq.mat );
 }
 
 
-void bruteCPU(matrix X, matrix Q, int *NNs){
+void bruteCPU(matrix X, matrix Q, unint *NNs){
   real *dtoNNs; 
   real temp;
 
-  int i, j;
+  unint i, j;
 
   dtoNNs = (real*)calloc(Q.r,sizeof(*dtoNNs));
   
@@ -75,7 +100,7 @@ void bruteCPU(matrix X, matrix Q, int *NNs){
     dtoNNs[i] = MAX_REAL;
     NNs[i] = 0;
     for(j=0; j<X.r; j++ ){
-      temp = distL1( Q, X, i, j );
+      temp = distVec( Q, X, i, j );
       if( temp < dtoNNs[i]){
        NNs[i] = j;
        dtoNNs[i] = temp;
@@ -85,4 +110,38 @@ void bruteCPU(matrix X, matrix Q, int *NNs){
   
   free(dtoNNs);  
 }
+
+
+//The following method works properly, but requires the GNU scientific
+//library.  If you want to use it, uncomment the code, uncomment the include
+//above, and adjust the makefile.  It was used for debugging purposes, but
+//is not required by anything else.
+
+/* void bruteKCPU(matrix x, matrix q, intMatrix NNs){ */
+/*   int i, j; */
+
+/*   float **d; */
+/*   d = (float**)calloc(q.pr, sizeof(*d)); */
+/*   size_t **t; */
+/*   t = (size_t**)calloc(q.pr, sizeof(*t)); */
+/*   for( i=0; i<q.pr; i++){ */
+/*     d[i] = (float*)calloc(x.pr, sizeof(**d)); */
+/*     t[i] = (size_t*)calloc(x.pr, sizeof(**t)); */
+/*   } */
+
+/*   for( i=0; i<q.r; i++){ */
+/*     for( j=0; j<x.r; j++) */
+/*       d[i][j] = distVec( q, x, i, j ); */
+/*     gsl_sort_float_index(t[i], d[i], 1, x.r); */
+/*     for ( j=0; j<KMAX; j++) */
+/*       NNs.mat[IDX( i, j, NNs.ld )] = t[i][j]; */
+/*   } */
+
+/*   for( i=0; i<q.pr; i++){ */
+/*     free(t[i]); */
+/*     free(d[i]); */
+/*   } */
+/*   free(t); */
+/*   free(d); */
+/* } */
 #endif