@@ -57,9 +57,9 @@ void malloc_gene_data(GENE_DATA* pdata)

   int nrow=pdata->nrow;

   int ncol=pdata->ncol;

-  pdata->id=(char**)Calloc(nrow,char*);

-  pdata->d=(float**)Calloc(nrow,float*);

-  pdata->L=(int*)Calloc(ncol,int);

+  pdata->id=(char**)R_Calloc(nrow,char*);

+  pdata->d=(float**)R_Calloc(nrow,float*);

+  pdata->L=(int*)R_Calloc(ncol,int);

   /*initialization*/

   memset(pdata->L,0,sizeof(int)*ncol);

@@ -67,8 +67,8 @@ void malloc_gene_data(GENE_DATA* pdata)

     pdata->L[i]=0;

   for (i=0; i<nrow; i++) {

-    pdata->id[i] = (char *) Calloc(MAX_ID,char);

-    pdata->d[i]=(float *) Calloc(ncol,float);

+    pdata->id[i] = (char *) R_Calloc(MAX_ID,char);

+    pdata->d[i]=(float *) R_Calloc(ncol,float);

  }

 }

@@ -80,12 +80,12 @@ void free_gene_data(GENE_DATA* pdata)

 {

   int i;

   for (i=0; i<pdata->nrow; i++) {

-    Free(pdata->d[i]);

-    Free(pdata->id[i]);

+    R_Free(pdata->d[i]);

+    R_Free(pdata->id[i]);

   }

-  Free(pdata->L);

-  Free(pdata->d);

-  Free(pdata->id);

+  R_Free(pdata->L);

+  R_Free(pdata->d);

+  R_Free(pdata->id);

 }

 /********************************************************************************/

@@ -142,11 +142,11 @@ void  get1pvalue(GENE_DATA* pdata,int* L,float* T,float* P,

   int nrow=pdata->nrow;

   int B=(*func_first_sample)(NULL);

   /*allocate the space and initialziation*/

-  bT=(float*)Calloc(nrow,float);

-  bL=(int*)Calloc(ncol,int);

-  count=(float*)Calloc(nrow,float);

+  bT=(float*)R_Calloc(nrow,float);

+  bL=(int*)R_Calloc(ncol,int);

+  count=(float*)R_Calloc(nrow,float);

   memset(count,0,sizeof(float)*nrow);

-  total=(int*)Calloc(nrow,int);

+  total=(int*)R_Calloc(nrow,int);

   memset(total,0,sizeof(int)*nrow);

   /*comuter the original one first*/

@@ -184,10 +184,10 @@ void  get1pvalue(GENE_DATA* pdata,int* L,float* T,float* P,

   }

   /*free the spaces*/

-  Free(bT);

-  Free(count);

-  Free(total);

-  Free(bL);

+  R_Free(bT);

+  R_Free(count);

+  R_Free(total);

+  R_Free(bL);

 }

 /********************************************************************************/

@@ -203,8 +203,8 @@ void sort_gene_data(GENE_DATA* pdata,int*R)

   int i,nrow=pdata->nrow;

   char** old_id; /*the old addresses of the gene id*/

   float** old_d;  /*th old addresses of the gene data*/

-  old_d=(float**)Calloc(nrow,float*);

-  old_id=(char**)Calloc(nrow,char*);

+  old_d=(float**)R_Calloc(nrow,float*);

+  old_id=(char**)R_Calloc(nrow,char*);

   /*store the original pointers from pdata*/

   for(i=0;i<nrow;i++)

     {

@@ -217,8 +217,8 @@ void sort_gene_data(GENE_DATA* pdata,int*R)

       pdata->d[i]=old_d[R[i]];

       pdata->id[i]=old_id[R[i]];

     }

-  Free(old_id);

-  Free(old_d);

+  R_Free(old_id);

+  R_Free(old_d);

 }

 /********************************************************************************/

 /*                    sort_vector                                               */

@@ -231,12 +231,12 @@ void sort_vector(float* V,int*R,int n)

 {

   float* old_V;

   int i;

-  old_V=(float*)Calloc(n,float);

+  old_V=(float*)R_Calloc(n,float);

   for(i=0;i<n;i++)

     old_V[i]=V[i];

   for(i=0;i<n;i++)

     V[i]=old_V[R[i]];

-  Free(old_V);

+  R_Free(old_V);

 }

 /********************************************************************************/

 /*                    get_all_samples_P                                         */

@@ -261,8 +261,8 @@ void get_all_samples_P(float* V, int n,float* P,float na,

   B=(*func_first_sample)(NULL);

   /*allocate the spaces*/

-  L=(int*)Calloc(n,int);

-  R=(int*)Calloc(B,int);

+  L=(int*)R_Calloc(n,int);

+  R=(int*)R_Calloc(B,int);

   /*compute all the test_stat*/

   (*func_first_sample)(L);

@@ -306,8 +306,8 @@ void get_all_samples_P(float* V, int n,float* P,float na,

     P[R[b]]=NA_FLOAT;

   /*free the space*/

-  Free(L);

-  Free(R);

+  R_Free(L);

+  R_Free(R);

 } 

 /*get all the samples of T and they're also ordered.It's used only for diagonsis*/

@@ -319,8 +319,8 @@ void get_all_samples_T(float* V, int n,float* T,float na,

   B=(*func_first_sample)(NULL);

   /*allocate the spaces*/

-  L=(int*)Calloc(n,int);

-  R=(int*)Calloc(B,int);

+  L=(int*)R_Calloc(n,int);

+  R=(int*)R_Calloc(B,int);

   /*compute all the test_stat*/

   (*func_first_sample)(L);

@@ -336,8 +336,8 @@ void get_all_samples_T(float* V, int n,float* T,float na,

   }

   if(myDEBUG)

     print_farray(stderr,T,B);

-  Free(L);

-  Free(R);

+  R_Free(L);

+  R_Free(R);

 } 

 void adj_pvalue_quick(GENE_DATA* pdata,float*T, float* P, 

@@ -353,10 +353,10 @@ void adj_pvalue_quick(GENE_DATA* pdata,float*T, float* P,

   /*allocate the space*/

   B=(*func_first_sample)(NULL);

-  L=(int*)Calloc(ncol,int);

-  R=(int*)Calloc(nrow,int);

-  all_P=(float*)Calloc(B,float);

-  all_Q=(float*)Calloc(B,float);

+  L=(int*)R_Calloc(ncol,int);

+  R=(int*)R_Calloc(nrow,int);

+  all_P=(float*)R_Calloc(B,float);

+  all_Q=(float*)R_Calloc(B,float);

   /*get the original unadjusted p-values first

    we'll use the normalized t-statistics*/

@@ -435,10 +435,10 @@ void adj_pvalue_quick(GENE_DATA* pdata,float*T, float* P,

       Adj_Lower[i]=Adj_Lower[i-1];

   /*free the spaces*/

-  Free(L);

-  Free(R);

-  Free(all_P);

-  Free(all_Q);

+  R_Free(L);

+  R_Free(R);

+  R_Free(all_P);

+  R_Free(all_Q);

 }

 /********************************************************************************/

@@ -478,18 +478,18 @@ void  adj_by_T(GENE_DATA* pdata,float* T,float* P,float*Adj_P,

   int nrow=pdata->nrow;

   int B=(*func_first_sample)(NULL);

   /*allocate the space and initialziation*/

-  bT=(float*)Calloc(nrow,float);

-  bL=(int*)Calloc(ncol,int);

-  count1=(float*)Calloc(nrow,float);

+  bT=(float*)R_Calloc(nrow,float);

+  bL=(int*)R_Calloc(ncol,int);

+  count1=(float*)R_Calloc(nrow,float);

   memset(count1,0,sizeof(float)*nrow);

-  total1=(int*)Calloc(nrow,int);

+  total1=(int*)R_Calloc(nrow,int);

   memset(total1,0,sizeof(int)*nrow);

-  count2=(float*)Calloc(nrow,float);

+  count2=(float*)R_Calloc(nrow,float);

   memset(count2,0,sizeof(float)*nrow);

-  total2=(int*)Calloc(nrow,int);

+  total2=(int*)R_Calloc(nrow,int);

   memset(total2,0,sizeof(int)*nrow);

-  R=(int*)Calloc(nrow,int);

+  R=(int*)R_Calloc(nrow,int);

    /*comuter the original t-statfirst*/

   compute_test_stat(pdata,pdata->L,T,func_stat,extra);

@@ -567,13 +567,13 @@ void  adj_by_T(GENE_DATA* pdata,float* T,float* P,float*Adj_P,

     if(Adj_P[i]<Adj_P[i-1])

       Adj_P[i]=Adj_P[i-1];

   /*free the spaces*/

-  Free(bT);

-  Free(count1);

-  Free(total1);

-  Free(count2);

-  Free(total2);

-  Free(bL);

-  Free(R);

+  R_Free(bT);

+  R_Free(count1);

+  R_Free(total1);

+  R_Free(count2);

+  R_Free(total2);

+  R_Free(bL);

+  R_Free(R);

 }      

 void set_seed_sampling(long int seed){

   g_random_seed=seed;

@@ -45,14 +45,14 @@ void create_sampling_pairt(int n,int*L,int B)

   }

   else{

     int* myL;

-    myL=(int*)Calloc(n,int);

+    myL=(int*)R_Calloc(n,int);

     l_B=B;

     l_is_random=1;

     /*fprintf(stderr,"\nWe're doing %d random permutations\n",l_B);*/

     Rprintf("\nWe're doing %d random permutations\n",l_B);

     set_seed(g_random_seed);

-    l_all_samples=(unsigned int*)Calloc(l_B*l_sz,int);

+    l_all_samples=(unsigned int*)R_Calloc(l_B*l_sz,int);

     /*setting the first sample as the original data*/

     set_binpermu(L,0,n,l_sz,l_len,l_B,l_all_samples);

     /*the extra as a buffer*/

@@ -68,7 +68,7 @@ void create_sampling_pairt(int n,int*L,int B)

       }

       set_binpermu(myL,i,n,l_sz,l_len,l_B,l_all_samples);

     }

-    Free(myL);

+    R_Free(myL);

     if(myDEBUG)

     {

       fprintf(stderr,"the samples are\n");

@@ -82,7 +82,7 @@ void delete_sampling_pairt()

 {

   if(l_is_random){

     if(l_B!=0){

-      Free(l_all_samples);

+      R_Free(l_all_samples);

       l_all_samples=NULL;

     }

   }

@@ -17,14 +17,14 @@ void create_sampling_pairt_fixed(int n,int*L,int B)

     fprintf(stderr,"B needs to be positive\n");

     return;/*exit(0)*/;

   }

-  l_L=(int*)Calloc(n, int);

+  l_L=(int*)R_Calloc(n, int);

   memcpy(l_L,L,sizeof(int)*n);

 }

 void delete_sampling_pairt_fixed()

 {

-  Free(l_L);

+  R_Free(l_L);

   l_L=NULL;

 }

 int first_sample_pairt_fixed(int *L)

@@ -78,9 +78,9 @@ void create_sampling(int n,int*L,int B)

     /*reintiailize the permu_array*/

     delete_permu_array(&l_pa);

     init_permu_array(&l_pa,L,n,B);

-    permun=(int*)Calloc(l_pa.n,int);

-    ordern=(int*)Calloc(l_pa.n,int);

-    myL=(int*)Calloc(l_pa.n,int);

+    permun=(int*)R_Calloc(l_pa.n,int);

+    ordern=(int*)R_Calloc(l_pa.n,int);

+    myL=(int*)R_Calloc(l_pa.n,int);

     for(i=0;i<n;i++){

       ordern[i]=i;

     }

@@ -94,9 +94,9 @@ void create_sampling(int n,int*L,int B)

       sample2label(n,l_pa.k,l_pa.nk,permun,myL);

       set_permu(&l_pa,i,myL);

     }

-    Free(myL);

-    Free(ordern);

-    Free(permun);

+    R_Free(myL);

+    R_Free(ordern);

+    R_Free(permun);

   }

 }

 void delete_sampling()

@@ -153,7 +153,7 @@ static int init_permu_array(PERMU_ARRAY* pa, int *L,int n, int B)

   (pa->k)++;

   /*compue nk*/

-  pa->nk=(int*)Calloc(pa->k,int);

+  pa->nk=(int*)R_Calloc(pa->k,int);

   memset(pa->nk,0,sizeof(int)*pa->k);

   for(i=0;i<n;i++)

     pa->nk[L[i]]++;

@@ -163,7 +163,7 @@ static int init_permu_array(PERMU_ARRAY* pa, int *L,int n, int B)

   pa->len=floor(log(imax+1.0)/log(pa->k)); 

   pa->sz=ceil(n/(pa->len*1.0));

   /*allocate the space for v*/

-  pa->v=(unsigned int*)Calloc(B*pa->sz,int);

+  pa->v=(unsigned int*)R_Calloc(B*pa->sz,int);

   return 1;

 }

@@ -212,10 +212,10 @@ static int set_permu(PERMU_ARRAY* pa, int h,int *L)

 }

 static void delete_permu_array(PERMU_ARRAY* pa)

 {

-  Free(pa->nk);

+  R_Free(pa->nk);

   pa->nk=NULL;

   if(pa->B!=0){

-    Free(pa->v);

+    R_Free(pa->v);

     pa->v=NULL;

   }

 }

@@ -23,7 +23,7 @@ void create_sampling_fixed(int n,int*L,int B)

     fprintf(stderr,"B needs to be positive\n");

     return;/*exit(0)*/;

   }

-  l_L=(int*)Calloc(n,int);

+  l_L=(int*)R_Calloc(n,int);

   memcpy(l_L,L,sizeof(int)*n);

   k=0;

@@ -32,26 +32,26 @@ void create_sampling_fixed(int n,int*L,int B)

       k=L[i];

   k++;

   l_k=k;

-  l_nk=(int*)Calloc(k,int);

+  l_nk=(int*)R_Calloc(k,int);

   memset(l_nk,0,sizeof(int)*k);

   for(i=0;i<n;i++)

     l_nk[L[i]]++;

-  l_permun=(int*)Calloc(n,int);

-  l_ordern=(int*)Calloc(n,int);

+  l_permun=(int*)R_Calloc(n,int);

+  l_ordern=(int*)R_Calloc(n,int);

   for(i=0;i<n;i++){

       l_ordern[i]=i;

     }

 }

 void delete_sampling_fixed()

 {

-  Free(l_L);

+  R_Free(l_L);

   l_L=NULL;

-  Free(l_nk);

+  R_Free(l_nk);

   l_nk=NULL;

-  Free(l_permun);

+  R_Free(l_permun);

   l_permun=NULL;

-  Free(l_ordern);

+  R_Free(l_ordern);

   l_ordern=NULL;

 }

@@ -255,9 +255,9 @@ float Fstat_num_denum(const float *Y, const int* L,const int n, const float na,f

 		   k is the number of groups,

 		   N is the total number of validate objects*/

   k=*(int*)extra;

-  meani=(float *)Calloc(k,float);

-  ssi=(float *)Calloc(k,float);

-  ni=(int *)Calloc(k,int);

+  meani=(float *)R_Calloc(k,float);

+  ssi=(float *)R_Calloc(k,float);

+  ni=(int *)R_Calloc(k,int);

   for(i=0;i<k;i++){

     meani[i]=0;/*intialize to be zero*/

     ssi[i]=0;

@@ -297,9 +297,9 @@ float Fstat_num_denum(const float *Y, const int* L,const int n, const float na,f

   /*summarize the num and denum*/

   *num=bss/(k-1.0);

   *denum=wss/(N-k-0.0);

-  Free(meani);

-  Free(ni);

-  Free(ssi);

+  R_Free(meani);

+  R_Free(ni);

+  R_Free(ssi);

   return 1;

 } 

 /*compute the Block F-stat for k samples, where L[i] is the labelling of object i,

@@ -328,8 +328,8 @@ float Block_Fstat_num_denum(const float *Y, const int* L,const int n, const floa

     fprintf(stderr,"The design is not balanced as B(%d)xm(%d)!=n(%d)\n",B,m,n);

     return NA_FLOAT;

   }

-  meani=(float *)Calloc(B,float);

-  meanj=(float *)Calloc(m,float);

+  meani=(float *)R_Calloc(B,float);

+  meanj=(float *)R_Calloc(m,float);

   for(i=0;i<B;i++){

     meani[i]=0;/*intialize to be zero*/

     for(j=0;j<m;j++){

@@ -369,8 +369,8 @@ float Block_Fstat_num_denum(const float *Y, const int* L,const int n, const floa

   /*summarize the num and denum*/

   *num=bss/(m-1.0);

   *denum=wss/((m-1.0)*(B-1.0));

-  Free(meani);

-  Free(meanj);

+  R_Free(meani);

+  R_Free(meanj);

   return 1;

 } 

 void int2bin(int r,int*V,int n)

@@ -501,7 +501,7 @@ void label2sample(int n, int k, int* nk,int*L,int *permun)

   int *s;/*s is for starting*/

   /*initialize the beginning*/

-  s=(int*)Calloc(k,int);

+  s=(int*)R_Calloc(k,int);

   s[0]=0;

   for(l=1;l<k;l++){

     s[l]=s[l-1]+nk[l-1];

@@ -511,17 +511,17 @@ void label2sample(int n, int k, int* nk,int*L,int *permun)

     permun[s[l]]=j;

     s[l]++;

   }

-  Free(s);

+  R_Free(s);

 }

 int next_label(int n, int k, int* nk, int*L)

 {

   int *permun,ret;

-  permun=(int*)Calloc(n,int);

+  permun=(int*)R_Calloc(n,int);

   label2sample(n,k,nk,L,permun);

   ret=next_mult_permu(permun,n,k,nk);

   sample2label(n,k,nk,permun,L);

-  Free(permun);

+  R_Free(permun);

   return ret;

 }

@@ -538,7 +538,7 @@ int next_two_permu(int* V, int n, int k)

   int* A=V;

   int* B=V+k;

   int* tempV,*cpyV;

-  tempV=(int*)Calloc(n,int);

+  tempV=(int*)R_Calloc(n,int);

   i=k-1;

   while(i>=0&& A[i]>maxb){

@@ -554,7 +554,7 @@ int next_two_permu(int* V, int n, int k)

     /*using the tempV to swap the array A and array B*/

     memcpy(V,tempV,sizeof(int)*n);

     /*coppying back to V*/

-    Free(tempV);

+    R_Free(tempV);

     return 0;

   }

   /*else to find the next permutation*/

@@ -574,7 +574,7 @@ int next_two_permu(int* V, int n, int k)

   /*copy the ((n-k)-(j+1)) elements from array 

     B[j+1],...B[n-k-1],..,A[i+1],..A[k-1]*/

   /*construct the array B[j+1],...B[n-k-1],A[i+1],..A[k-1]*/

-  cpyV=(int*)Calloc(n,int);

+  cpyV=(int*)R_Calloc(n,int);

   memcpy(cpyV,B+j+1,sizeof(int)*((n-k)-(j+1)));

   if(k>(i+1))

     memcpy(cpyV+(n-k)-(j+1),A+i+1,sizeof(int)*(k-(i+1)));

@@ -584,8 +584,8 @@ int next_two_permu(int* V, int n, int k)

     memcpy(tempV+k+j+2,cpyV+(k-i),sizeof(int)*((n-k)-(j+2)));

   /*copy back to V*/

   memcpy(V,tempV,sizeof(int)*n);

-  Free(cpyV);

-  Free(tempV);

+  R_Free(cpyV);

+  R_Free(tempV);

   return 1;

 }

@@ -642,14 +642,14 @@ int next_permu(int*V,int n) /* n has to be at least 2*/

     if(V[j]>old) break;

     j--;

   }

-  cpyV=(int*)Calloc(n,int);

+  cpyV=(int*)R_Calloc(n,int);

   memcpy(cpyV,V,sizeof(int)*n);

   V[i]=cpyV[j];

   cpyV[j]=old;

   for(l=i+1;l<n;l++){

     V[l]=cpyV[n+i-l];

   }

-  Free(cpyV);

+  R_Free(cpyV);

   return 1;

 }

@@ -51,7 +51,7 @@ void order_mult_data(int* R,int n,int k,...)

   CMP_DATA *cmp_data;

   va_list ap;

   int i;

-  cmp_data=(CMP_DATA*)Calloc(k,CMP_DATA);

+  cmp_data=(CMP_DATA*)R_Calloc(k,CMP_DATA);

   va_start(ap,k);

   for(i=0;i<k;i++) {

     cmp_data[i].V=va_arg(ap,float*);

@@ -63,7 +63,7 @@ void order_mult_data(int* R,int n,int k,...)

   for(i=0;i<n;i++)

     R[i]=i;

   qsort(R,n,sizeof(R[0]),cmp_mult);

-  Free(cmp_data);

+  R_Free(cmp_data);

 }  

 void order_data(float* V,int*R,int n,FUNC_CMP func_cmp)