Ejemplo n.º 1
0
// Determines the total number of computations needed by RBC to 
// find the the NNS.  This function is useful mainly for 
// evaluating the effectiveness of the RBC.  
void searchStats(matrix q, matrix x, matrix r, rep *ri, double *avgDists){
  unint i, j;
  unint *repID = (unint*)calloc(q.pr, sizeof(*repID));
  real *dToReps = (real*)calloc(q.pr, sizeof(*dToReps));

  brutePar(r,q,repID,dToReps);

  //for each q, need to determine which reps to examine
  size_t numAdded=0;
  size_t totalComp=0;
#pragma omp parallel for private(j) reduction(+:numAdded,totalComp)
  for(i=0; i<q.r; i++){
    for(j=0; j<r.r; j++ ){
      real temp = distVec( q, r, i, j );
      //dToRep[i] is current UB on dist to i's NN
      //temp - ri[j].radius is LB to dist belonging to rep j
      if( dToReps[i] >= temp - ri[j].radius && temp <= 3.0*dToReps[i] ){
	numAdded++;
	totalComp+=ri[j].len;
      }
    }
  }
  
  *avgDists = ((double)totalComp)/((double)q.r);
  free(repID);
  free(dToReps);
}
Ejemplo n.º 2
0
//This is a still crude, but doesn't ignore the cache at least
void bruteMap2(matrix X, matrix Q, rep *ri, unint* qMap, unint *NNs, real *dToNNs){
  unint i, j, k;
  
#pragma omp parallel for private(j,k)
  for( i=0; i<Q.pr/CL; i++ ){
    unint row = i*CL;
    for(j=0; j<CL; j++){
      dToNNs[row+j] = MAX_REAL;
      NNs[row+j] = 0;
    }
    
    real temp;
    rep rt[CL];
    unint maxLen = 0;
    for(j=0; j<CL; j++){
      rt[j] = ri[qMap[row+j]];
      maxLen = MAX(maxLen, rt[j].len);
    }  
    
    for(k=0; k<maxLen; k++ ){
      for(j=0; j<CL; j++ ){
	if( k<rt[j].len ){
	  temp = distVec( Q, X, row+j, rt[j].lr[k] );
	  if( temp < dToNNs[row+j]){
	    NNs[row+j] = rt[j].lr[k];
	    dToNNs[row+j] = temp;
	  }
	}
      }
    }
  }
}
Ejemplo n.º 3
0
void bruteKDists(matrix x, matrix q, size_t **NNs, real **D, unint k){
  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));
  }

#pragma omp parallel for private(j)
  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<k; j++){
      NNs[i][j]=t[i][j];
      D[i][j]=d[i][t[i][j]];
    }
  }

  for( i=0; i<q.pr; i++){
    free(t[i]);
    free(d[i]);
  }
  free(t);
  free(d);
}
Ejemplo n.º 4
0
void CMixtureGaussianKernel::InitAdaptive(const CVisDMatrix& vCentralData, int nWithin2Sigma)
{
	m_nCluster = vCentralData.NRows();
	m_vData = vCentralData;

	nWithin2Sigma++;
	assert((m_nCluster > nWithin2Sigma)&&(nWithin2Sigma>2));

	// Estimate sigma
	double Sigma;
	{
		double avgDist = 0;

		for (int iStep = 0; iStep < nWithin2Sigma; iStep++ )
		{
			CVisDVector distVec(m_nCluster);
			// Random choose center
			int iChoose = MyRand() * (m_nCluster - 1);
			for (int iData = 0; iData < m_nCluster; iData++ )
			{
				CVisDVector tempVec = vCentralData.Row(iChoose);
				tempVec = tempVec - vCentralData.Row(iData);
				double dist = sqrt(tempVec * tempVec);
				distVec[iData] = dist;
			}
	
			// Find the nWidthin2Sigma-th minvalue
			double fMax = VisDVectorMaxData(distVec);
			double fMin;
			for ( int iMin = 0; iMin < nWithin2Sigma; iMin++ )
			{
				int iTemp = VisDVectorMinIndex(distVec);
				fMin = distVec[iTemp];
				distVec[iTemp] = fMax;
			}	
			
			avgDist += fMin;
		}
		avgDist /= nWithin2Sigma;
		Sigma = avgDist / 2;
	}
	
	m_nDataDimesion = vCentralData.NCols();
	m_vMixingWeight.Resize(m_nCluster);

	double weight = (double)1.0 / m_nCluster;
	for (int iCluster = 0; iCluster < m_nCluster ; iCluster++ )
	{
		m_vMixingWeight[iCluster] = weight;
	}
	
	m_vClusterModel.resize(m_nCluster);
	for (iCluster = 0; iCluster < m_nCluster; iCluster++ )
	{
		m_vClusterModel[iCluster].SetModel(m_nDataDimesion, vCentralData.Row(iCluster), Sigma);
	}
}
Ejemplo n.º 5
0
	void v3color_object::test<19>()
	{
		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2);
		F32 val = distVec(llcolor3,llcolor3a);
		ensure("distVec failed ", is_approx_equal(fsqrtf((r1-r2)*(r1-r2) + (g1-g2)*(g1-g2) + (b1-b2)*(b1-b2)) ,val));
		
		F32 val1 = distVec_squared(llcolor3,llcolor3a);
		ensure("distVec_squared failed ", is_approx_equal(((r1-r2)*(r1-r2) + (g1-g2)*(g1-g2) + (b1-b2)*(b1-b2)) ,val1));
	}
Ejemplo n.º 6
0
// Exact k-NN search with the RBC.  This version works better on computers
// with a high core count (say > 4)
void searchExactManyCoresK(matrix q, matrix x, matrix r, rep *ri, unint **NNs, real **dNNs, unint K){
  unint i, j, k;
  unint **repID = (unint**)calloc(q.pr, sizeof(*repID));
  for(i=0; i<q.pr; i++)
    repID[i] = (unint*)calloc(K, sizeof(**repID));
  real **dToReps = (real**)calloc(q.pr, sizeof(*dToReps));
  for(i=0; i<q.pr; i++)
    dToReps[i] = (real*)calloc(K, sizeof(**dToReps));
  intList *toSearch = (intList*)calloc(r.pr, sizeof(*toSearch));
  for(i=0;i<r.pr;i++)
    createList(&toSearch[i]);
  
  bruteKHeap(r,q,repID,dToReps,K);

#pragma omp parallel for private(j,k)
  for(i=0; i<r.pr/CL; i++){
    unint row = CL*i;
    real temp[CL];
    
    for(j=0; j<q.r; j++ ){
      for(k=0; k<CL; k++){
	temp[k] = distVec( q, r, j, row+k );
      }
      for(k=0; k<CL; k++){
	//dToRep[j] is current UB on dist to j's NN
	//temp - ri[i].radius is LB to dist belonging to rep i
	if( row+k<r.r && 3.0*dToReps[j][K-1] >= temp[k] && dToReps[j][K-1] >= temp[k] - ri[row+k].radius) 
	  addToList(&toSearch[row+k], j); //query j needs to search rep 
      }
    }
    for(j=0;j<CL;j++){
      if(row+j<r.r){
	while(toSearch[row+j].len % CL != 0)
	  addToList(&toSearch[row+j],DUMMY_IDX);	
      }
    }
  }

  bruteListK(x,q,ri,toSearch,r.r,NNs,dToReps,K);
  
  for(i=0; i<q.r; i++){
    for(j=0; j<K; j++)
      dNNs[i][j]=dToReps[i][j];
  }

  for(i=0;i<q.pr;i++)
    free(dToReps[i]);
  free(dToReps);
  for(i=0;i<r.pr;i++)
    destroyList(&toSearch[i]);
  free(toSearch);
  for(i=0;i<q.pr;i++)
    free(repID[i]);
  free(repID);
}
Ejemplo n.º 7
0
void rangeCount(matrix X, matrix Q, real *ranges, unint *counts){
  real temp;
  unint i, j;

#pragma omp parallel for private(j,temp)
  for( i=0; i<Q.r; i++ ){
    counts[i] = 0;
    for(j=0; j<X.r; j++ ){
      temp = distVec( Q, X, i, j );
      counts[i] += ( temp < ranges[i] );
    }
  }
}
Ejemplo n.º 8
0
// A basic implementation of brute force k-NN search.  This does not
// use a heap.  Instead it computes all distances and then sorts.
void bruteK(matrix x, matrix q, unint **NNs, float **dToNNs, unint k) {
    int i, j, l;
    int nt = omp_get_max_threads();

    float ***d;
    size_t ***t;
    d = (float***)calloc(nt, sizeof(*d));
    t = (size_t***)calloc(nt, sizeof(*t));
    for(i=0; i<nt; i++) {
        d[i] = (float**)calloc(CL, sizeof(**d));
        t[i] = (size_t**)calloc(CL, sizeof(**t));
        for(j=0; j<CL; j++) {
            d[i][j] = (float*)calloc(x.pr, sizeof(***d));
            t[i][j] = (size_t*)calloc(x.pr, sizeof(***t));
        }
    }

    #pragma omp parallel for private(j,l) shared(d,t,k)
    for( i=0; i<q.pr/CL; i++) {
        int row = i*CL;
        int tn = omp_get_thread_num(); //thread num

        for( j=0; j<x.r; j++) {
            for( l=0; l<CL; l++) {
                d[tn][l][j] =  distVec( q, x, row+l, j);
            }
        }
        for(l=0; l<CL; l++)
            gsl_sort_float_smallest_index(t[tn][l], k, d[tn][l], 1, x.r);

        for(l=0; l<CL; l++) {
            if(row+l<q.r) {
                for(j=0; j<k; j++) {
                    NNs[row+l][j] = (unint)t[tn][l][j];
                    dToNNs[row+l][j] = d[tn][l][t[tn][l][j]];
                }
            }
        }
    }

    for(i=0; i<nt; i++) {
        for(j=0; j<CL; j++) {
            free(d[i][j]);
            free(t[i][j]);
        }
        free(d[i]);
        free(t[i]);
    }
    free(t);
    free(d);
}
Ejemplo n.º 9
0
void brute(matrix X, matrix Q, unint *NNs, real *dToNNs){
  real temp;
  unint i, j;

  for( i=0; i<Q.r; i++ ){
    dToNNs[i] = MAX_REAL;
    NNs[i] = 0;
    for(j=0; j<X.r; j++ ){
      temp = distVec( Q, X, i, j );
      if( temp < dToNNs[i]){
	NNs[i] = j;
	dToNNs[i] = temp;
      }
    }
  }
}
Ejemplo n.º 10
0
// Exact 1-NN search with the RBC.  This version works better on computers
// with a high core count (say > 4)
void searchExactManyCores(matrix q, matrix x, matrix r, rep *ri, unint *NNs, real *dToNNs){
  unint i, j, k;
  unint *repID = (unint*)calloc(q.pr, sizeof(*repID));
  real *dToReps = (real*)calloc(q.pr, sizeof(*dToReps));
  intList *toSearch = (intList*)calloc(r.pr, sizeof(*toSearch));
  
  for(i=0;i<r.pr;i++)
    createList(&toSearch[i]);

  brutePar(r,q,repID,dToReps);

#pragma omp parallel for private(j,k)
  for(i=0; i<r.pr/CL; i++){
    unint row = CL*i;
    real temp[CL];
    
    for(j=0; j<q.r; j++ ){
      for(k=0; k<CL; k++){
	temp[k] = distVec( q, r, j, row+k );
      }
      for(k=0; k<CL; k++){
	//dToRep[j] is current UB on dist to j's NN
	//temp - ri[i].radius is LB to dist belonging to rep i
	if( row+k<r.r && dToReps[j] >= temp[k] - ri[row+k].radius && 3.0*dToReps[j] >= temp[k] )
	  addToList(&toSearch[row+k], j); //need to search rep 
      }
    }
    for(j=0;j<CL;j++){
      if(row+j<r.r){
	while(toSearch[row+j].len % CL != 0)
	  addToList(&toSearch[row+j],DUMMY_IDX);	
      }
    }
  }

  //Most of the time is spent in this method
  bruteList(x,q,ri,toSearch,r.r,NNs,dToReps);
  
  for(i=0; i<q.r; i++)
    dToNNs[i] = dToReps[i];
  
  for(i=0;i<r.pr;i++)
    destroyList(&toSearch[i]);
  free(toSearch);
  free(repID);
  free(dToReps);
}
Ejemplo n.º 11
0
// Performs a range count using brute force.
void rangeCount(matrix X, matrix Q, float *ranges, unint *counts) {
    float temp;
    unint i, j, k;

    #pragma omp parallel for private(j,k,temp) shared(counts,ranges)
    for( i=0; i<Q.pr/CL; i++ ) {
        unint row = i*CL;
        for( j=0; j<CL; j++)
            counts[row+j] = 0;
        for(k=0; k<X.r; k++ ) {
            for( j=0; j<CL; j++) {
                temp = distVec( Q, X, row+j, k );
                counts[row+j] += ( temp < ranges[row+j] );
            }
        }
    }
}
Ejemplo n.º 12
0
//This is a very crude implementation without any reordering of q
void bruteMap(matrix X, matrix Q, rep *ri, unint* qMap, unint *NNs, real *dToNNs){
  real temp;
  unint i, j;
  
#pragma omp parallel for private(j,temp)
  for( i=0; i<Q.r; i++ ){
    dToNNs[i] = MAX_REAL;
    NNs[i] = 0;
    rep rt = ri[qMap[i]];
    for(j=0; j<rt.len; j++ ){
      temp = distVec( Q, X, i, rt.lr[j] );
      if( temp < dToNNs[i]){
	NNs[i] = rt.lr[j];
	dToNNs[i] = temp;
      }
    }
  }
}
Ejemplo n.º 13
0
// Most basic implementation of parallel brute force search.  Not very fast.
void brutePar(matrix X, matrix Q, unint *NNs, real *dToNNs){
  real temp;
  int i, j;
 
  
#pragma omp parallel for private(j,temp)
  for( i=0; i<Q.r; i++ ){
    dToNNs[i] = MAX_REAL;
    NNs[i] = 0;
    for(j=0; j<X.r; j++ ){
      temp = distVec( Q, X, i, j );
      if( temp < dToNNs[i]){
	NNs[i] = j;
	dToNNs[i] = temp;
      }
    }
  }
}
Ejemplo n.º 14
0
void bruteList(matrix X, matrix Q, rep *ri, intList *toSearch, unint numReps, unint *NNs, real *dToNNs){
  real temp;
  unint i, j, k, l;
  
  for(i=0; i<Q.r; i++){
    dToNNs[i] = MAX_REAL;
    NNs[i] = 0;
  }

#pragma omp parallel for private(j,k,l,temp)
  for( i=0; i<numReps; i++ ){
    for( j=0; j< toSearch[i].len/CL; j++){  //toSearch is assumed to be padded
      unint row = j*CL;
      unint qInd[CL];
      for(k=0; k<CL; k++)
	qInd[k] = toSearch[i].x[row+k];
      rep rt = ri[i];
      unint curMinInd[CL];
      real curMinDist[CL];
      for(k=0; k<CL; k++)
	curMinDist[k] = MAX_REAL;
      for(k=0; k<rt.len; k++){
	for(l=0; l<CL; l++ ){
	  if(qInd[l]!=DUMMY_IDX){
	    temp = distVec( Q, X, qInd[l], rt.lr[k] );
	    if( temp < curMinDist[l] ){
	      curMinInd[l] = rt.lr[k];
	      curMinDist[l] = temp;
	    }
	  }
	}
      }
#pragma omp critical
      {
	for(k=0; k<CL; k++){
	  if( qInd[k]!=DUMMY_IDX && curMinDist[k] < dToNNs[qInd[k]]){
	    NNs[qInd[k]] = curMinInd[k];
	    dToNNs[qInd[k]] = curMinDist[k];
	  }
	}
      }
    }
  }
}
Ejemplo n.º 15
0
void evalApprox(matrix q, matrix x, unint *NNs){
  real *ranges = (real*)calloc(q.pr, sizeof(*ranges));
  unint *counts = (unint*)calloc(q.pr,sizeof(*counts));
  unint i;

  for(i=0; i<q.r; i++)
    ranges[i] = distVec(q,x,i,NNs[i]);

  rangeCount(x,q,ranges,counts);

  double avgCount = 0.0;
  for(i=0; i<q.r; i++)
    avgCount += ((double)counts[i]);
  avgCount/=q.r;
  printf("average num closer = %6.5f \n",avgCount);

  free(counts);
  free(ranges);
}
Ejemplo n.º 16
0
void searchExact2(matrix q, matrix x, matrix r, rep *ri, unint *NNs){
  unint i, j;
  unint *repID = (unint*)calloc(q.pr, sizeof(*repID));
  real *dToReps = (real*)calloc(q.pr, sizeof(*dToReps));
  intList *toSearch = (intList*)calloc(r.pr, sizeof(*toSearch));
  for(i=0;i<r.pr;i++)
    createList(&toSearch[i]);
  
  struct timeval tvB,tvE;

  gettimeofday(&tvB,NULL);
  brutePar2(r,q,repID,dToReps);
  gettimeofday(&tvE,NULL);
  printf("[SE]brutePar2 time elapsed = %6.4f \n", timeDiff(tvB,tvE) );

  gettimeofday(&tvB,NULL);
#pragma omp parallel for private(j)
  for(i=0; i<r.r; i++){
    for(j=0; j<q.r; j++ ){
      real temp = distVec( q, r, j, i );
      //dToRep[j] is current UB on dist to j's NN
      //temp - ri[i].radius is LB to dist belonging to rep i
      if( dToReps[j] >= temp - ri[i].radius)
	addToList(&toSearch[i], j); //need to search rep i
    }
    while(toSearch[i].len % CL != 0)
      addToList(&toSearch[i],DUMMY_IDX);
  }
  gettimeofday(&tvE,NULL);
  printf("[SE]loop time elapsed = %6.4f \n", timeDiff(tvB,tvE) );

  gettimeofday(&tvB,NULL);
  bruteListRev(x,q,ri,toSearch,r.r,NNs,dToReps);
  gettimeofday(&tvE,NULL);
  printf("[SE]bruteListRev time elapsed = %6.4f \n", timeDiff(tvB,tvE) );

  for(i=0;i<r.pr;i++)
    destroyList(&toSearch[i]);
  free(toSearch);
  free(repID);
  free(dToReps);
}
Ejemplo n.º 17
0
void bruteList(matrix X, matrix Q, rep *ri, intList *toSearch, unint *NNs, real *dToNNs){
  real temp;
  unint i, j, k;
  
#pragma omp parallel for private(j,k,temp)
  for( i=0; i<Q.r; i++ ){
    dToNNs[i] = MAX_REAL;
    NNs[i] = 0;
    for( j=0; j<toSearch[i].len; j++ ){
      rep rt = ri[ toSearch[i].x[j] ];
      for(k=0; k<rt.len; k++ ){
	temp = distVec( Q, X, i, rt.lr[k] );
	if( temp < dToNNs[i]){
	  NNs[i] = rt.lr[k];
	  dToNNs[i] = temp;
	}
      }
    }
  }
}
Ejemplo n.º 18
0
void bruteCache(matrix X, matrix Q, unint *NNs, real *dToNNs){
  real temp[CL];

  int i, j, k, t;
  for( i=0; i<Q.pr/CL; i++ ){
    t = i*CL;
    for(j=0;j<CL;j++){
      dToNNs[t+j] = MAX_REAL;
      NNs[t+j] = 0;
    }
    for(j=0; j<X.r; j++ ){
      for(k=0; k<CL; k++){
	temp[k] = distVec( Q, X, t+k, j );
      }
      for(k=0; k<CL; k++){
	if( temp[k] < dToNNs[t+k]){
	  NNs[t+k] = j;
	  dToNNs[t+k] = temp[k];
	}
      }
    }
  }
}
Ejemplo n.º 19
0
// Performs a brute force NN search, but only between queries and points
// belonging to each query's nearest representative.  This method is used by
// the one-shot algorithm.
void bruteMap(matrix X, matrix Q, rep *ri, unint* qMap, unint *NNs, float *dToNNs) {
    unint i, j, k;

    //Sort the queries, so that queries matched to a particular representative
    //will be processed together, improving cache performance.
    size_t *qSort = (size_t*)calloc(Q.pr, sizeof(*qSort));
    gsl_sort_uint_index(qSort,qMap,1,Q.r);

    #pragma omp parallel for private(j,k) schedule(static)
    for( i=0; i<Q.pr/CL; i++ ) {
        unint row = i*CL;
        for(j=0; j<CL; j++) {
            dToNNs[qSort[row+j]] = MAX_float;
        }

        float temp;
        rep rt[CL];
        unint maxLen = 0;
        for(j=0; j<CL; j++) {
            rt[j] = ri[qMap[qSort[row+j]]];
            maxLen = MAX(maxLen, rt[j].len);
        }

        for(k=0; k<maxLen; k++ ) {
            for(j=0; j<CL; j++ ) {
                if( k<rt[j].len ) {
                    temp = distVec( Q, X, qSort[row+j], rt[j].lr[k] ); //change to LB
                    if( temp < dToNNs[qSort[row+j]]) {
                        NNs[qSort[row+j]] = rt[j].lr[k];
                        dToNNs[qSort[row+j]] = temp;
                    }
                }
            }
        }
    }
    free(qSort);
}
Ejemplo n.º 20
0
int main(int argc, char *argv[]) {

  // This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
  int iprint     = argc - 1;
  Teuchos::RCP<std::ostream> outStream;
  Teuchos::oblackholestream bhs; // outputs nothing

  /*** Initialize communicator. ***/
  Teuchos::GlobalMPISession mpiSession (&argc, &argv, &bhs);
  Teuchos::RCP<const Teuchos::Comm<int> > comm = Tpetra::DefaultPlatform::getDefaultPlatform().getComm();
  const int myRank = comm->getRank();
  if ((iprint > 0) && (myRank == 0)) {
    outStream = Teuchos::rcp(&std::cout, false);
  }
  else {
    outStream = Teuchos::rcp(&bhs, false);
  }

  int errorFlag  = 0;

  // *** Example body.
  try {

    /*** Read in XML input ***/
    std::string filename = "input.xml";
    Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
    Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
    filename = "SROMinput.xml";
    Teuchos::RCP<Teuchos::ParameterList> SROMlist = Teuchos::rcp( new Teuchos::ParameterList() );
    Teuchos::updateParametersFromXmlFile( filename, SROMlist.ptr() );

    /*** Initialize main data structure. ***/
    Teuchos::RCP<StefanBoltzmannData<RealT> > data = Teuchos::rcp(new StefanBoltzmannData<RealT>(comm, parlist, outStream));

    /*** Build vectors and dress them up as ROL vectors. ***/
    Teuchos::RCP<const Tpetra::Map<> > vecmap_u = data->getMatA()->getDomainMap();
    Teuchos::RCP<const Tpetra::Map<> > vecmap_z = data->getMatB()->getDomainMap();
    Teuchos::RCP<const Tpetra::Map<> > vecmap_c = data->getMatA()->getRangeMap();
    Teuchos::RCP<Tpetra::MultiVector<> > u_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
    Teuchos::RCP<Tpetra::MultiVector<> > z_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
    Teuchos::RCP<Tpetra::MultiVector<> > c_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_c, 1, true));
    Teuchos::RCP<Tpetra::MultiVector<> > du_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
    Teuchos::RCP<Tpetra::MultiVector<> > dz_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
    Teuchos::RCP<Tpetra::MultiVector<> > Eu_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
    Teuchos::RCP<Tpetra::MultiVector<> > Vu_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
    // Set all values to 1 in u, z and c.
    u_rcp->putScalar(1.0);
    z_rcp->putScalar(1.0);
    c_rcp->putScalar(1.0);
    // Randomize d vectors.
    du_rcp->randomize();
    dz_rcp->randomize();
    // Create ROL::TpetraMultiVectors.
    Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(u_rcp));
    Teuchos::RCP<ROL::Vector<RealT> > zp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(z_rcp));
    Teuchos::RCP<ROL::Vector<RealT> > cp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(c_rcp));
    Teuchos::RCP<ROL::Vector<RealT> > dup = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(du_rcp));
    Teuchos::RCP<ROL::Vector<RealT> > dzp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(dz_rcp));
    Teuchos::RCP<ROL::Vector<RealT> > Eup = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(Eu_rcp));
    Teuchos::RCP<ROL::Vector<RealT> > Vup = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(Vu_rcp));
    // Create ROL SimOpt vectors.
    ROL::Vector_SimOpt<RealT> x(up,zp);
    ROL::Vector_SimOpt<RealT> d(dup,dzp);

    /*** Build objective function, constraint and reduced objective function. ***/
    Teuchos::RCP<ROL::Objective_SimOpt<RealT> > obj =
      Teuchos::rcp(new Objective_PDEOPT_StefanBoltzmann<RealT>(data, parlist));
    Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > con =
      Teuchos::rcp(new EqualityConstraint_PDEOPT_StefanBoltzmann<RealT>(data, parlist));
    Teuchos::RCP<ROL::Reduced_Objective_SimOpt<RealT> > objReduced =
      Teuchos::rcp(new ROL::Reduced_Objective_SimOpt<RealT>(obj, con, up, zp, up));

    /*** Build stochastic functionality. ***/
    int sdim = parlist->sublist("Problem").get("Stochastic Dimension",4);
    // Build batch manager
    Teuchos::RCP<ROL::BatchManager<RealT> > bman
      = Teuchos::rcp(new ROL::BatchManager<RealT>());
    // Build sampler
    std::vector<Teuchos::RCP<ROL::Distribution<RealT> > > distVec(sdim);
    Teuchos::ParameterList distList;
    distList.sublist("SOL").sublist("Distribution").set("Name","Uniform");
    distList.sublist("SOL").sublist("Distribution").sublist("Uniform").set("Lower Bound",-1.0);
    distList.sublist("SOL").sublist("Distribution").sublist("Uniform").set("Upper Bound", 1.0);
    for (int d = 0; d < sdim; d++) {
      distVec[d] = ROL::DistributionFactory<RealT>(distList);
    }
    Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler
      = Teuchos::rcp(new ROL::SROMGenerator<RealT>(*SROMlist,bman,distVec));
    // Build stochastic problem
    ROL::StochasticProblem<RealT> opt(*parlist,objReduced,sampler,zp);

    /*** Check functional interface. ***/
    std::vector<RealT> par(sdim,1.0);
    obj->setParameter(par);
    con->setParameter(par);
    objReduced->setParameter(par);
    obj->checkGradient(x,d,true,*outStream);
    obj->checkHessVec(x,d,true,*outStream);
    con->checkApplyJacobian(x,d,*up,true,*outStream);
    con->checkApplyAdjointHessian(x,*dup,d,x,true,*outStream);
    con->checkAdjointConsistencyJacobian(*dup,d,x,true,*outStream);
    con->checkInverseJacobian_1(*up,*up,*up,*zp,true,*outStream);
    con->checkInverseAdjointJacobian_1(*up,*up,*up,*zp,true,*outStream);
    objReduced->checkGradient(*zp,*dzp,true,*outStream);
    objReduced->checkHessVec(*zp,*dzp,true,*outStream);
    opt.checkObjectiveGradient(*dzp,true,*outStream);
    opt.checkObjectiveHessVec(*dzp,true,*outStream);

    /*** Solve optimization problem. ***/
    ROL::Algorithm<RealT> algo_tr("Trust Region",*parlist,false);
    zp->zero(); // set zero initial guess
    algo_tr.run(opt, true, *outStream);

    *outStream << " Solution Statistic: S(z) = " << opt.getSolutionStatistic() << "\n";

    data->outputTpetraVector(z_rcp, "control.txt");

    RealT w = 0.0, tol = 1.e-8;
    ROL::Elementwise::Power<RealT> sqr(2.0);
    Eup->zero(); Vup->zero();
    Teuchos::RCP<ROL::Vector<RealT> > up2 = up->clone();
    for (int i = 0; i < sampler->numMySamples(); i++) {
      // Get samples and weights
      par = sampler->getMyPoint(i);
      w   = sampler->getMyWeight(i);
      // Solve state equation at current sample
      con->setParameter(par);
      con->solve(*cp,*up,*zp,tol);
      // Accumulate expected value
      Eup->axpy(w,*up);
      // Accumulate variance
      up2->set(*up); up2->applyUnary(sqr);
      Vup->axpy(w,*up2);
    }
    up2->set(*Eup); up2->applyUnary(sqr);
    Vup->axpy(-1.0,*up2);
    if (sampler->numMySamples() > 1) {
      Vup->scale((RealT)sampler->numMySamples()/(RealT)(sampler->numMySamples()-1));
    }
    data->outputTpetraVector(Eu_rcp, "expected_value_state.txt");
    data->outputTpetraVector(Vu_rcp, "variance_state.txt");
  }
  catch (std::logic_error err) {
    *outStream << err.what() << "\n";
    errorFlag = -1000;
  }; // end try

  if (errorFlag != 0)
    std::cout << "End Result: TEST FAILED\n";
  else
    std::cout << "End Result: TEST PASSED\n";

  return 0;
}
vector<unsigned> Hypergraph::getDistToModification(const vector<int> &modifySet)
{
	int nTotal = _nVertices+_edges.size();
	vector<unsigned> distVec (nTotal);
	distVec.assign(nTotal, 100);

	for (int i=0; i<modifySet.size(); ++i)
	{
		distVec[modifySet[i]] = 0;
	}

	int nEdges = _edges.size();
	vector<unsigned> pathBuf (nEdges*(nEdges+1)/2);
	pathBuf.assign(nEdges*(nEdges+1)/2, 100);

	/*initialization*/
	for (int i=0; i<nEdges; ++i)
	{
		for (int j=0; j<i; ++j)
		{
			HyperEdge v(_edges[i].size()+_edges[j].size());
			HyperEdge::iterator vIt = set_intersection(_edges[i].begin(), _edges[i].begin(), _edges[j].begin(), _edges[j].end(), v.begin());
			if (vIt!=v.begin())
			{
				pathBuf[i*(i-1)/2+j] = 2;
			}
		}

		for (int j=0; j<modifySet.size(); ++j)
		{
			int modifiedIdx = modifySet[j];
			HyperEdge::iterator it = find(_edges[i].begin(), _edges[i].end(), modifiedIdx);
			if (it!=_edges[i].end())
			{
				pathBuf[nEdges*(nEdges-1)/2+i] = 1;
				break;
			}
		}
	}

	for (int k=0; k<nEdges+1; ++k)
	{
		for (int i=0; i<nEdges+1; ++i)
		{
			if (i==k)
			{
				continue;
			}
			for (int j=0; j<i; ++j)
			{
				if (j==k)
				{
					continue;
				}
				int idxIJ = i*(i-1)/2+j;
				int idxIK = i>k?i*(i-1)/2+k:k*(k-1)/2+i;
				int idxJK = j>k?j*(j-1)/2+k:k*(k-1)/2+j;

				pathBuf[idxIJ] = min(pathBuf[idxIJ], pathBuf[idxIK]+pathBuf[idxJK]);
			}
		}
	}

	for (int i=0; i<nEdges; ++i)
	{
		distVec[i+_nVertices] = pathBuf[nEdges*(nEdges-1)/2+i];
		for (int j=0; j<_edges[i].size(); ++j)
		{
			distVec[_edges[i][j]] = min(distVec[i+_nVertices]+1, distVec[_edges[i][j]]);
		}
	}

	return distVec;
}
Ejemplo n.º 22
0
int main(int argc, char* argv[]) {

  Teuchos::GlobalMPISession mpiSession(&argc, &argv);
  Teuchos::RCP<const Teuchos::Comm<int> > commptr =
    Teuchos::DefaultComm<int>::getComm();

  // This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
  int iprint     = argc - 1;
  Teuchos::RCP<std::ostream> outStream;
  Teuchos::oblackholestream bhs; // outputs nothing
  if (iprint > 0 && commptr->getRank() == 0)
    outStream = Teuchos::rcp(&std::cout, false);
  else
    outStream = Teuchos::rcp(&bhs, false);

  int errorFlag  = 0;

  try {
    /**********************************************************************************************/
    /************************* CONSTRUCT SOL COMPONENTS *******************************************/
    /**********************************************************************************************/
    // Set random seed
    srand(123456789);
    // Build samplers
    size_t dimension = 1;

    // Initialize distribution
    Teuchos::RCP<ROL::Distribution<RealT> > dist;
    std::vector<Teuchos::RCP<ROL::Distribution<RealT> > > distVec(dimension);
    Teuchos::ParameterList Dlist;
    Dlist.sublist("SOL").sublist("Distribution").set("Name","Beta");
    RealT alpha = 1., beta = 4.;
    // Fill moment vector and initial guess
    for (size_t d = 0; d < dimension; d++) {
      // Build distribution for dimension d
      alpha++; beta++;
      Dlist.sublist("SOL").sublist("Distribution").sublist("Beta").set("Shape 1",alpha);
      Dlist.sublist("SOL").sublist("Distribution").sublist("Beta").set("Shape 2",beta);
      dist = ROL::DistributionFactory<RealT>(Dlist);
      distVec[d] = ROL::DistributionFactory<RealT>(Dlist);
    }

    // Get ROL parameterlist
    std::string filename = "input_04.xml";
    Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
    Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );

    Teuchos::ParameterList &list = parlist->sublist("SOL").sublist("Sample Generator").sublist("SROM");
    Teuchos::Array<int> moments = Teuchos::getArrayFromStringParameter<int>(list,"Moments");
    size_t numMoments = static_cast<size_t>(moments.size());

    std::clock_t timer = std::clock();
    Teuchos::RCP<ROL::BatchManager<RealT> > bman =
      Teuchos::rcp(new ROL::TeuchosBatchManager<RealT,int>(commptr));
    Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler =
      Teuchos::rcp(new ROL::SROMGenerator<RealT>(*parlist,bman,distVec));
    *outStream << std::endl << "Sample Time: "
               << (std::clock()-timer)/(RealT)CLOCKS_PER_SEC << " seconds"
               << std::endl;

    RealT val = 0., error = 0., data = 0., sum = 0.;
    *outStream << std::endl;
    *outStream << std::scientific << std::setprecision(11);
    *outStream << std::right << std::setw(20) << "Computed Moment"
                             << std::setw(20) << "True Moment"
                             << std::setw(20) << "Relative Error"
                             << std::endl;
    for (size_t m = 0; m < numMoments; m++) {
      for (size_t d = 0; d < dimension; d++) {
        val = 0.; data = distVec[d]->moment(moments[m]);
        for (size_t k = 0; k < (size_t)sampler->numMySamples(); k++) {
          val += sampler->getMyWeight(k)*std::pow((sampler->getMyPoint(k))[d],moments[m]);
        }
        bman->sumAll(&val,&sum,1);
        error = std::abs(sum-data)/std::abs(data);
        if ( error > 1.e-1 ) {
          errorFlag++;
        }
        *outStream << std::right << std::setw(20) << sum
                                 << std::setw(20) << data
                                 << std::setw(20) << error
                                 << std::endl;
      }
    }
    *outStream << std::endl;

//    std::ofstream file;
//    std::stringstream name;
//    name << "samples." << commptr->getRank() << ".txt";
//    file.open(name.str().c_str()); 
//    for (size_t k = 0; k < (size_t)sampler->numMySamples(); k++) {
//      for (size_t d = 0; d < dimension; d++) {
//        file << std::setprecision(std::numeric_limits<RealT>::digits10)
//             << std::scientific
//             << (sampler->getMyPoint(k))[d];
//        file << "  ";
//      }
//      file << std::setprecision(std::numeric_limits<RealT>::digits10)
//           << std::scientific
//           << sampler->getMyWeight(k) << std::endl;
//    }
//    file.close();
//    commptr->barrier();

  }
  catch (std::logic_error err) {
    *outStream << err.what() << "\n";
    errorFlag = -1000;
  }; // end try

  if (errorFlag != 0)
    std::cout << "End Result: TEST FAILED\n";
  else
    std::cout << "End Result: TEST PASSED\n";

  return 0;
}
Ejemplo n.º 23
0
//Exact 1-NN search with the RBC.
void searchExact(matrix q, matrix x, matrix r, rep *ri, unint *NNs, real *dToNNs){
  unint i, j, k;
  unint *repID = (unint*)calloc(q.pr, sizeof(*repID));
  real *dToReps = (real*)calloc(q.pr, sizeof(*dToReps));
  intList *toSearch = (intList*)calloc(r.pr, sizeof(*toSearch));
  for(i=0;i<r.pr;i++)
    createList(&toSearch[i]);
  int nt = omp_get_max_threads();
  
  float ***d;  //d is indexed by: thread, cache line #, rep #
  d = (float***)calloc(nt, sizeof(*d));
  for(i=0; i<nt; i++){
    d[i] = (float**)calloc(CL, sizeof(**d));
    for(j=0; j<CL; j++){
      d[i][j] = (float*)calloc(r.pr, sizeof(***d));
    }
  }
  
#pragma omp parallel for private(j,k) //schedule(dynamic)
  for(i=0; i<q.pr/CL; i++){
    unint row = i*CL;
    unint tn = omp_get_thread_num();
    
    unint minID[CL];
    real minDist[CL];
    for(j=0;j<CL;j++)
      minDist[j] = MAX_REAL;
    
    for( j=0; j<r.r; j++ ){
      for(k=0; k<CL; k++){
	d[tn][k][j] = distVec(q, r, row+k, j);
	if(d[tn][k][j] < minDist[k]){
	  minDist[k] = d[tn][k][j]; //gamma
	  minID[k] = j;
	}
      }
    }

    for( j=0; j<CL; j++ )
      dToReps[row+j] = minDist[j];

    for(j=0; j<r.r; j++ ){
      for(k=0; k<CL; k++ ){
	real temp = d[tn][k][j];
	if( row + k<q.r && minDist[k] >= temp - ri[j].radius && 3.0*minDist[k] >= temp ){
#pragma omp critical
	  {
	    addToList(&toSearch[j], row+k);
	  }
	}
      }
    }
  }
  for(i=0; i<r.r; i++){
    while(toSearch[i].len % CL != 0)
      addToList(&toSearch[i],DUMMY_IDX);
  }

  bruteList(x,q,ri,toSearch,r.r,NNs,dToReps);
  
  for(i=0; i<q.r; i++)
    dToNNs[i] = dToReps[i];
  
  for(i=0;i<r.pr;i++)
    destroyList(&toSearch[i]);
  free(toSearch);
  free(repID);
  free(dToReps);
  for(i=0; i<nt; i++){
    for(j=0; j<CL; j++)
      free(d[i][j]); 
    free(d[i]);
  }
  free(d);
}
Ejemplo n.º 24
0
//Exact k-NN search with the RBC
void searchExactK(matrix q, matrix x, matrix r, rep *ri, unint **NNs, real **dNNs, unint K){
  unint i, j, k;
  unint *repID = (unint*)calloc(q.pr, sizeof(*repID));
  real **dToReps = (real**)calloc(q.pr, sizeof(*dToReps));
  for(i=0; i<q.pr; i++)
    dToReps[i] = (real*)calloc(K, sizeof(**dToReps));
  intList *toSearch = (intList*)calloc(r.pr, sizeof(*toSearch));
  for(i=0;i<r.pr;i++)
    createList(&toSearch[i]);
  int nt = omp_get_max_threads();

  float ***d;  //d is indexed by: thread, cache line #, rep #
  d = (float***)calloc(nt, sizeof(*d));
  for(i=0; i<nt; i++){
    d[i] = (float**)calloc(CL, sizeof(**d));
    for(j=0; j<CL; j++){
      d[i][j] = (float*)calloc(r.pr, sizeof(***d));
    }
  }
  
  heap **hp;
  hp = (heap**)calloc(nt, sizeof(*hp));
  for(i=0; i<nt; i++){
    hp[i] = (heap*)calloc(CL, sizeof(**hp));
    for(j=0; j<CL; j++)
      createHeap(&hp[i][j],K);
  }
  
#pragma omp parallel for private(j,k)
  for(i=0; i<q.pr/CL; i++){
    unint row = i*CL;
    unint tn = omp_get_thread_num();
    heapEl newEl; 

    for( j=0; j<r.r; j++ ){
      for(k=0; k<CL; k++){
	d[tn][k][j] = distVec(q, r, row+k, j);
	if( d[tn][k][j] < hp[tn][k].h[0].val ){
	  newEl.id = j;
	  newEl.val = d[tn][k][j];
	  replaceMax( &hp[tn][k], newEl );
	}
      }
    }
    for(j=0; j<r.r; j++ ){
      for(k=0; k<CL; k++ ){
	real minDist = hp[tn][k].h[0].val;
	real temp = d[tn][k][j];
	if( row + k<q.r && minDist >= temp - ri[j].radius && 3.0*minDist >= temp ){
#pragma omp critical
	  {
	    addToList(&toSearch[j], row+k);
	  }
	}
      }
    }
    for(j=0; j<CL; j++)
      reInitHeap(&hp[tn][j]);
  }

  for(i=0; i<r.r; i++){
    while(toSearch[i].len % CL != 0)
      addToList(&toSearch[i],DUMMY_IDX);
  }

  bruteListK(x,q,ri,toSearch,r.r,NNs,dNNs,K);

  
  //clean-up
  for(i=0; i<nt; i++){
    for(j=0; j<CL; j++)
      destroyHeap(&hp[i][j]);
    free(hp[i]);
  }
  free(hp);
  for(i=0;i<r.pr;i++)
    destroyList(&toSearch[i]);
  free(toSearch);
  free(repID);
  for(i=0;i<q.pr; i++)
    free(dToReps[i]);
  free(dToReps);
  for(i=0; i<nt; i++){
    for(j=0; j<CL; j++)
      free(d[i][j]); 
    free(d[i]);
  }
  free(d);
}