int main()
{
	FILE *f=fopen("heapsort.csv","w");
	int i,n;
	for(n=10;n<=1000;n=n+10)
	{
	int a[n];
	for(i=0;i<n;i++)
	{
		a[i]=rand()%10000;
	}
	
	
	heapsort(a,n);
	fprintf(f,"%d\n",counter);
	/*for(i=0;i<n;i++)
	{
		printf("%d ",a[i]);
	}*/
	}
	//printf("%d\n",a[0]);
	return 0;
}
void main()
{
	char a[100][100],swap[100],tc,b[100];
	int i,n,x;
	clock_t start,end;
 	double exe_time;
	if(scanf("%d%c",&n,&tc)==2 && tc=='\n'&& n>0)
	{
	for(i=1;i<=n;i++)
		{
			scanf("%s",a[i]);
			strcpy(b,a[i]);
			if(validy(b))
				continue;
			else
			{
				printf("\n Enter a valid string \n");
				exit(1);
			}
        }
	start=clock();
	heapsort(a,n);
	end=clock();
    printf("\nThe sorted array is: \n");
    for(i=1;i<=n;i++)
        {
            printf("%s\n",a[i]);
        }
	exe_time=(double)(end-start)/CLOCKS_PER_SEC;
 	printf("The execution time is %lf \n",exe_time);
	}
	else
	{
		printf("\n Enter valid number \n");
		exit(1);
	}
}
Exemple #3
0
// Custom introsort algorithm that combines quicksort, heapsort and insertion sort
static void main_sort(T* vector, int left, int right, comparation(*expression)(T, T), int depth)
{
	// Stop at the base case and calculate the length of the current vector
	if (left >= right) return;
	int len = right - left + 1;
	
	// If the maximum number of recursive calls has been reached, switch to heapsort
	if (depth == 0) heapsort(vector + left, len, expression);
	else
	{
		// Avoid the recursion and switch to insertion sort with small vectors
		if (len < MIN_QUICKSORT_SIZE)
		{
			insertion_sort(vector + left, len, expression);
		}
		else
		{
			// Classic quicksort step
			int part = partition(vector, left, right, expression);
			main_sort(vector, left, part - 1, expression, depth - 1);
			main_sort(vector, part + 1, right, expression, depth - 1);
		}
	}
}
Exemple #4
0
int main(void) {
        clock_t t0, t1;
        float t;
        const unsigned num_elems=1000;
        int *arr=genarr(num_elems);
        printf("Initial array:\n");
        print_intarr(arr, num_elems);
        printf("\n");

        t0 = clock();
        heapsort(arr, num_elems);
        t1 = clock();


        printf("\nFinal array:\n");
        print_intarr(arr, num_elems);

        printf("\n\n");
        t = (((float) t1) - ((float) t0))/((float) CLOCKS_PER_SEC);
        printf("The sort operation took %f seconds\n", t);
        //don't forget to free!
        free(arr);
        return 0;
}
Exemple #5
0
int
main(int argc, char *argv[]) {
#ifdef SMALL_PROBLEM_SIZE
#define LENGTH 800000
#else
#define LENGTH 8000000
#endif
    int N = ((argc == 2) ? atoi(argv[1]) : LENGTH);
    double *ary;
    int i;
    
    /* create an array of N random doubles */
    ary = (double *)malloc((N+1) * sizeof(double));
    for (i=1; i<=N; i++) {
	ary[i] = gen_random(1);
    }

    heapsort(N, ary);

    printf("%f\n", ary[N]);

    free(ary);
    return(0);
}
Exemple #6
0
void CSortManager::HeapSort(std::string inputfilepath, bool large)
{
	long long int size = 0;
	if (large)
		size = ( INT_MAX / 4000 );
	else
		size = 10000;

	try
	{
		CHeapSort heapsort(size);
		heapsort.FileToSort(inputfilepath);
		heapsort.Parse();

		std::clock_t start;
		double duration;

		start = std::clock();

		heapsort.Sort();

		duration = (std::clock() - start) / (double)CLOCKS_PER_SEC;

		std::string outfilepath = "sortedlist_heapsort.txt";
		heapsort.WriteSortedListToFile(outfilepath);

		std::string sorttype = "Heap Sort";
		if (largedataset) printTimingsLarge(sorttype, duration);
		else printTimingsSmall(sorttype, duration);
	}
	catch (std::exception ex)
	{
		CLogger::Log(__LINE__, __FILE__, ex.what());
	}
	
}
int main(int argc, char **argv) {
  heapsort();
  return 0;
}
Exemple #8
0
int main(int argc, char **argv)
{
    element list[27];
    int i;
    element temp;

    for (i = 0; i < 27; i++)
    {
        list[i].key = i;
    }

    permute(list, 27);

    printf("before insert sort\n"); 
    for (i = 0; i < 27; i++)
    {
        printf("%d " ,  list[i].key);
    }
    printf("\n");
    
    insertion_sort(list, 27); 
    printf("after insert  sort\n"); 
    for (i = 0; i < 27; i++)
    {
        printf("%d " ,  list[i].key);
    }
    printf("\n\n");


    permute(list, 27);

    printf("before quik sort\n"); 
    for (i = 0; i < 27; i++)
    {
        printf("%d " ,  list[i].key);
    }
    printf("\n");
    
    quiksort(list, 0, 26); 
    printf("after quik  sort\n"); 
    for (i = 0; i < 27; i++)
    {
        printf("%d " ,  list[i].key);
    }
    printf("\n\n");

    permute(list, 27);

    printf("before merge sort\n"); 
    for (i = 0; i < 27; i++)
    {
        printf("%d " ,  list[i].key);
    }
    printf("\n");
    
    merge_sort(list, 27); 
    printf("after merge  sort\n"); 
    for (i = 0; i < 27; i++)
    {
        printf("%d " ,  list[i].key);
    }
    printf("\n\n");

    permute(list, 27);
    SWAP(list[0], list[26], temp);

    printf("before heap sort\n"); 
    for (i = 0; i < 27; i++)
    {
        printf("%d " ,  list[i].key);
    }
    printf("\n");
    
    heapsort(list, 26); 
    printf("after heap sort\n"); 
    for (i = 0; i < 27; i++)
    {
        printf("%d " ,  list[i].key);
    }
    printf("\n");
}
Exemple #9
0
// This function creates a KD tree with the given
// points, array, and length
int KDTree::create(float *setpoints, int setnpoints, int setndim,
									 bool setCopy, struct KDTreeNode *setNodeMem)
{
  ndim = setndim;
  npoints = setnpoints;
  typedef int *intptr;
	
  // Copy the points from the original array, if necessary
  copyPoints = setCopy;
  if (copyPoints) {
    if(points) delete[] points;
    points = new float[ndim*npoints];
    memcpy(points,setpoints,sizeof(float)*ndim*npoints);
  }
  // If we are not copying, just set the pointer
  else
    points = setpoints;


  // Allocate some arrays;
  if (workArr)
    delete[]workArr;
  workArr = new int[npoints];

	if(!setNodeMem) {
		if(m_Root) delete[] m_Root;
		m_Root = new struct KDTreeNode[npoints*2+1];
		nodeMemAlloc = true;
	}
	else {
		m_Root = setNodeMem;
		nodeMemAlloc = false;
	}
	nodeMemCnt = 0;

	// Alocate array used for indexing
	if(intArrMem) delete[] intArrMem;
	intArrMem = 
		new int[(int)((float)(npoints+4)*
									ceil(log((double)npoints)/log(2.0)))];
	intArrMemCnt = 0;

  // Create the "sortidx" array by 
  // sorting the range tree points on each dimension
  int **sortidx = new intptr[ndim];
	if(verbosity>1)
		logmsg("KDTree: Sorting points\n");
	float imin[3];
	float imax[3];
	imin[0] = imin[1] = imin[2] = 999999.f;
	imax[0] = imax[1] = imax[2] = -999999.f;
  for (int i = 0; i < ndim; i++) {
    // Initialize the sortidx array for this
    // dimension
    sortidx[i] = new int[npoints];

    // Initialize the "tmp" array for the sort
    int *tmp = new int[npoints];
    for (int j = 0; j < npoints; j++)
      tmp[j] = j;

    // Sort the points on dimension i, putting
    // indexes in array "tmp"
    heapsort(i,tmp,npoints);

    // sortidx is actually the inverse of the 
    // index sorts
    for (int j = 0; j < npoints; j++)
	{
		sortidx[i][tmp[j]] = j;
		imin[i] = min( points[ j*3 + i ], imin[ i ] );
		imax[i] = max( points[ j*3 + i ], imax[ i ] );
	}
    delete[] tmp;
  }
	if(verbosity > 1)
		logmsg("KDTree: Done sorting points\n");

  // Create an initial list of points that references 
  // all the points
  int *pidx = new int[npoints];
  for (int i = 0; i < npoints; i++)
    pidx[i] = i;

  // Build a KD Tree
  AABB extents;
  Vec3 vmin(  imin[0] ,
			 imin[1],
			 imin[2]  );
  Vec3 vmax(  imax[0] ,
			 imax[1],
			 imax[2]  );
  OutputVector( vmin, "VMin");
  OutputVector( vmax, "VMax");
  extents.Set( vmin,vmax );
  m_Root->bounds.Set( vmin, vmax );
	//add objects to this node
	if( m_NodeCreationCallBack )
	{
		(*m_NodeCreationCallBack)( m_Root );
	}
  build_kdtree(sortidx,	// array of sort values
							 0,	// The current dimension
							 pidx, npoints, extents);	// The list of points
  // Delete the sort index
  for (int i = 0; i < ndim; i++)
    delete[]sortidx[i];
  delete[] sortidx;

  // Delete the initial list of points
  delete[] pidx;

	// Delete the sort arrays
	delete[] intArrMem;

	// delete the work array
  if(workArr) {
    delete[] workArr;
    workArr = (int *)NULL;
  }

	if(verbosity > 1)
		logmsg("KDTree: Done creating tree\n");
  return 0;
}				// end of create      
Exemple #10
0
void run_tests(int64_t *sizes, int sizes_cnt, int type)
{
  int test, res;
  double usec1, usec2, diff;

  printf("-------\nRunning tests with %s:\n-------\n", test_names[type]);

  res = 0;
  diff = 0;
  printf("%-20s", "stdlib qsort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    qsort(dst, size, sizeof(int64_t), simple_cmp);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);

#ifndef __linux__
  res = 0;
  diff = 0;
  printf("%-20s", "stdlib heapsort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    heapsort(dst, size, sizeof(int64_t), simple_cmp);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);

  res = 0;
  diff = 0;
  printf("%-20s", "stdlib mergesort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    mergesort(dst, size, sizeof(int64_t), simple_cmp);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);

#endif
  res = 0;
  diff = 0;
  printf("%-20s", "quick sort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_quick_sort(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  } 
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
    
  if (MAXSIZE < 10000)
  {
	  res = 0;
	  diff = 0;
    printf("%-20s", "bubble sort");
    for (test = 0; test < sizes_cnt; test++)
    {
      int64_t size = sizes[test];
      int64_t dst[size];
      fill(dst, size, type);
	  usec1 = utime();
      sorter_bubble_sort(dst, size);
	  usec2 = utime();
      verify(dst, size);
	if (!res) break;
	  diff += usec2 - usec1;
    }
	printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);

	res = 0;
	diff = 0;
    printf("%-20s", "binary insertion sort\n");
    for (test = 0; test < sizes_cnt; test++)
    {
      int64_t size = sizes[test];
      int64_t dst[size];
      fill(dst, size, type);
	  usec1 = utime();
      sorter_binary_insertion_sort(dst, size);
	  usec2 = utime();
      verify(dst, size);
	if (!res) break;
	  diff += usec2 - usec1;
    }
	printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
  }
      
  res = 0;
  diff = 0;
  printf("%-20s", "merge sort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_merge_sort(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
    
   
  res = 0;
  diff = 0;
  printf("%-20s", "heap sort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_heap_sort(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
    
  res = 0;
  diff = 0;
  printf("%-20s", "shell sort time");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_shell_sort(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
    
  res = 0;
  diff = 0;
  printf("%-20s", "tim sort"); 
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_tim_sort(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);

  res = 0;
  diff = 0;
  printf("%-20s", "in-place merge sort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_merge_sort_in_place(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
}
void CSRdouble::loadFromFileCOO(const char* file)
{
    fstream fin(file, ios::in);
    cout << "opening file: " << file << " in mode: ";
    if (!fin.is_open())
    {
        cout << "couldn't open file ... " << file << "\n";
        exit(1);
    }


   cout << " ascii" << std::endl;

   fin >> nrows >> ncols >> nonzeros;

   cout << "nrows:    " << nrows    << std::endl;
   cout << "ncols:    " << ncols    << std::endl;
   cout << "nonzeros: " << nonzeros << std::endl;

   pRows = new int[nrows+1];
   pCols = new int[nonzeros];
   pData = new double[nonzeros];

   int i, j, i0;
   double aij;
   int index;
   vector<vector<int> > vvcols(nrows+1);
   vector<vector<double> > vvdata(nrows+1);
   for (index = 0; index < nonzeros; index++)
   {
       fin >> i >> j >> aij;
       vvcols[i].push_back(j);
       vvdata[i].push_back(aij);
   }

   if (vvcols[0].empty())
     i0 = 1;
   else
     i0 = 0;
   
   fin.close();

   index = 0;
   pRows[0] = 0;
   for (i = i0; i < nrows+i0; i++)
   {
     int entries = vvcols[i].size();
     heapsort(entries, &vvcols[i][0], &vvdata[i][0]);

     memcpy(&pData[index], &vvdata[i][0], entries*sizeof(double));
     memcpy(&pCols[index], &vvcols[i][0], entries*sizeof(int));

     index += entries;
     pRows[i+1-i0] = index;
   }



   for (i = 0; i < nrows+1; i++)
   {
       pRows[i] -= i0;
   }

   for (i = 0; i < nonzeros; i++)
   {
       pCols[i] -= i0;
   }
}
Exemple #12
0
void *heap(void *arg)
{
  struct data *d = (struct data*) arg;
  heapsort((*d).a, (*d).size);
}
Exemple #13
0
void handler(struct hashtable *h_ex, struct hashtable *h_ex_in,
		 	 struct hashtable *h_in, struct hashtable *h_in_in,
		 	 keys *ex_keyhead, keys *in_keyhead,
		 	 u_long in_bytes_count,  u_int in_packets_count, u_long out_bytes_count, u_int out_packets_count)
{
	struct hashtable *h_ex_old = h_ex, *h_ex_in_old = h_ex_in;
	struct hashtable *h_in_old = h_in, *h_in_in_old = h_in_in;
	keys *ex_keyhead_old = ex_keyhead, *in_keyhead_old = in_keyhead;
	keys *ex_ret, *ex_rethead, *in_ret, *in_rethead;
	value *v;
	xvalue vs[1025];
	int sock;
	int i;
	struct sockaddr_in svraddr;
//	char sip[INET_ADDRSTRLEN], dip[INET_ADDRSTRLEN];

	if((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0){
		syslog(LOG_ERR, "Socket: %s", strerror(errno));
		exit(1);
	}

	svraddr.sin_family = AF_INET;
	svraddr.sin_port = htons(PORT);
	if(inet_pton(AF_INET, IP, &svraddr.sin_addr) < 0){
		syslog(LOG_ERR, "inet_pton: %s", strerror(errno));
		exit(1);
	}

	if (connect(sock, (const struct sockaddr *)&svraddr, sizeof(svraddr)) < 0){
		syslog(LOG_ERR, "connect: %s", strerror(errno));
		close(sock);
		return;
	}

	memset(&vs[0], 0, sizeof(xvalue));
	vs[0].v.other = 0;
	vs[0].fbytes = out_bytes_count;
	vs[0].fpacket = out_packets_count;
	if (ex_keyhead_old->next){
		if (!ex_keyhead_old->next->next){
			v = hashtable_search(h_ex_old, ex_keyhead_old->next->key);
			vs[1].v = *v;

			if ((v = hashtable_search(h_ex_in_old, ex_keyhead_old->next->key)) == NULL){
				vs[1].fbytes = 0;
				vs[1].fpacket = 0;
			}else{
				vs[1].fbytes = v->bytes;
				vs[1].fpacket = v->packets;
			}

			write(sock, vs, sizeof(xvalue) * 2);
			/*
			if ((inet_ntop(AF_INET, &vs[1].v.sip, sip, INET_ADDRSTRLEN) == NULL) || (inet_ntop(AF_INET, &vs[1].v.dip, dip, INET_ADDRSTRLEN) == NULL)){
				syslog(LOG_ERR, "inet_ntop: %s", strerror(errno));
				return;
			}
			printf("Ex_in   %s --> %s, bytes: %i, packets: %i\n", sip, dip, vs[1].v.bytes, vs[1].v.packets);
			*/
		}else{
			if((ex_ret = heapsort(h_ex_old, ex_keyhead_old, 1)) == NULL)
				syslog(LOG_ERR, "heapSort error");
			else{
				ex_rethead = ex_ret;
				i = 1;
				for(ex_ret = ex_ret->next; ex_ret; ex_ret = ex_ret->next)
				{
					v = hashtable_search(h_ex_old, ex_ret->key);
					vs[i].v = *v;

					if ((v = hashtable_search(h_ex_in_old, ex_ret->key)) == NULL){
						vs[i].fbytes = 0;
						vs[i].fpacket = 0;
					}else{
						vs[i].fbytes = v->bytes;
						vs[i].fpacket = v->packets;
					}

					/*
					if ((inet_ntop(AF_INET, &vs[i].v.sip, sip, INET_ADDRSTRLEN) == NULL) || (inet_ntop(AF_INET, &vs[i].v.dip, dip, INET_ADDRSTRLEN) == NULL)){
						syslog(LOG_ERR, "inet_ntop: %s", strerror(errno));
						return;
					}
					printf("Ex_in  %s --> %s, bytes: %i, packets: %i\n", sip, dip, vs[i].v.bytes, vs[i].v.packets);
					*/
					i++;
				}
				write(sock, vs, sizeof(xvalue) * i);
				for(; ex_rethead; free(ex_ret))
				{
                    ex_ret = ex_rethead;
                    ex_rethead = ex_rethead->next;
				}


			}
		}
	}else
		write(sock, vs, sizeof(xvalue));
	close(sock);

	if((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0){
		syslog(LOG_ERR, "Socket: %s", strerror(errno));
		exit(1);
	}
	if (connect(sock, (const struct sockaddr *)&svraddr, sizeof(svraddr)) < 0){
		syslog(LOG_ERR, "connect: %s", strerror(errno));
		close(sock);
		return;
	}
	memset(&vs[0], 0, sizeof(xvalue));
	vs[0].v.other = 1;
	vs[0].fbytes = in_bytes_count;
	vs[0].fpacket = in_packets_count;
	if (in_keyhead_old->next){
		if (!in_keyhead_old->next->next){
			v = hashtable_search(h_in_old, in_keyhead_old->next->key);
			vs[1].v = *v;

			if ((v = hashtable_search(h_in_in_old, in_keyhead_old->next->key)) == NULL){
				vs[1].fbytes = 0;
				vs[1].fpacket = 0;
			}else{
				vs[1].fbytes = v->bytes;
				vs[1].fpacket = v->packets;
			}

			write(sock, vs, sizeof(xvalue) * 2);
			/*
			if ((inet_ntop(AF_INET, &v->sip, sip, INET_ADDRSTRLEN) == NULL) || (inet_ntop(AF_INET, &v->dip, dip, INET_ADDRSTRLEN) == NULL)){
				syslog(LOG_ERR, "inet_ntop: %s", strerror(errno));
				return;
			}
			printf("In   %s --> %s, bytes: %i, packets: %i\n", sip, dip, v->bytes, v->packets);
			*/
		}else{
			if((in_ret = heapsort(h_in_old, in_keyhead_old, 0)) == NULL)
				syslog(LOG_ERR, "heapSort error");
			else{
				in_rethead = in_ret;
				i = 1;
				for(in_ret = in_ret->next; in_ret ; in_ret  = in_ret->next)
				{
					v = hashtable_search(h_in_old, in_ret ->key);
					vs[i].v = *v;

					if ((v = hashtable_search(h_in_in_old, in_ret->key)) == NULL){
						vs[i].fbytes = 0;
						vs[i].fpacket = 0;
					}else{
						vs[i].fbytes = v->bytes;
						vs[i].fpacket = v->packets;
					}
					i++;
					/*
					if ((inet_ntop(AF_INET, &v->sip, sip, INET_ADDRSTRLEN) == NULL) || (inet_ntop(AF_INET, &v->dip, dip, INET_ADDRSTRLEN) == NULL)){
						syslog(LOG_ERR, "inet_ntop: %s", strerror(errno));
						return;
					}
					printf("In  %s --> %s, bytes: %i, packets: %i\n", sip, dip, v->bytes, v->packets);
					*/
				}
				write(sock, vs, sizeof(xvalue) * i);
				for(; in_rethead; free(in_ret))
				{
                    in_ret = in_rethead;
                    in_rethead = in_rethead->next;
				}

			}
		}
	}else
		write(sock, vs, sizeof(xvalue));

	close(sock);


}
Exemple #14
0
void run_tests2(void)
{
  int i;
  int64_t arr[SIZE];
  int64_t dst[SIZE];
  double start_time;
  double end_time;
  double total_time;

  printf("Running tests - 2\n");
  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    qsort(dst, SIZE, sizeof(int64_t), simple_cmp2);

    end_time = utime();
    total_time += end_time - start_time;
    verify2(dst, SIZE);
  }
  printf("stdlib qsort time: %.2f us per iteration\n", total_time / RUNS);

#ifndef __linux__
  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    heapsort(dst, SIZE, sizeof(int64_t), simple_cmp2);

    end_time = utime();
    total_time += end_time - start_time;
    verify2(dst, SIZE);
  }
  printf("stdlib heapsort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    mergesort(dst, SIZE, sizeof(int64_t), simple_cmp2);

    end_time = utime();
    total_time += end_time - start_time;
    verify2(dst, SIZE);
  }
  printf("stdlib mergesort time: %.2f us per iteration\n", total_time / RUNS);
#endif

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter2_quick_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify2(dst, SIZE);
  }
  printf("quick sort time: %.2f us per iteration\n", total_time / RUNS);


  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter2_bubble_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify2(dst, SIZE);
  }
  printf("bubble sort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter2_merge_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify2(dst, SIZE);
  }
  printf("merge sort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter2_binary_insertion_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify2(dst, SIZE);
  }
  printf("binary insertion sort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter2_heap_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify2(dst, SIZE);
  }
  printf("heap sort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter2_shell_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify2(dst, SIZE);
  }
  printf("shell sort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter2_tim_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify2(dst, SIZE);
  }
  printf("tim sort time: %.2f us per iteration\n", total_time / RUNS);
}
Exemple #15
0
static int MStep(Tsc *solucion){

Tsc estim_cp;
int i,cnt,res;
float error_ratio, error;
float cosw, sinw, dtx, dty, tmp1, tmp2;
static TAsoc cp_tmp[MAXLASERPOINTS+1];

// Filtering of the spurious data
// Used the trimmed versions that orders the point by distance between associations

	if (params.filter<1){

	// Add Null element in array position 0	(this is because heapsort requirement)
	for (i=0;i<cntAssociationsT;i++){
	cp_tmp[i+1]=cp_associations[i];
	}
	cp_tmp[0].dist=-1;
	// Sort array
	heapsort(cp_tmp, cntAssociationsT);
	// Filter out big distances
	cnt=((int)(cntAssociationsT*100*params.filter))/100;
	// Remove Null element
	for (i=0;i<cnt;i++){
	cp_associationsTemp[i]=cp_tmp[i+1];
	}
}
else{ // Just build the Temp array to minimize
	cnt=0;
	for (i=0; i<cntAssociationsT;i++){
	if (cp_associations[i].dist<params.Br){
		cp_associationsTemp[cnt]=cp_associations[i];
		cnt++;
	}
	}
}

cntAssociationsTemp=cnt;

#ifdef INTMATSM_DEB
	printf("All assoc: %d  Filtered: %d  Percentage: %f\n",
	cntAssociationsT, cntAssociationsTemp, cntAssociationsTemp*100.0/cntAssociationsT);
#endif

// ---
/* Do de minimization Minimize Metric-based distance */
/* This function is optimized to speed up */

res=computeMatrixLMSOpt(cp_associationsTemp,cnt,&estim_cp);
if (res==-1)
	return -1;

#ifdef INTMATSM_DEB
	printf("estim_cp: <%f %f %f>\n",estim_cp.x, estim_cp.y,estim_cp.tita);
	printf("New impl: <%f %f %f>\n",estim_cp.x, estim_cp.y,estim_cp.tita);
#endif

cosw=(float)cos(estim_cp.tita); sinw=(float)sin(estim_cp.tita);
dtx=estim_cp.x; dty=estim_cp.y;


// ------
/* Compute the error of the associations */

error=0;
for (i = 0; i<cnt;i++){
	tmp1=cp_associationsTemp[i].nx * cosw - cp_associationsTemp[i].ny * sinw + dtx - cp_associationsTemp[i].rx;tmp1*=tmp1;
	tmp2=cp_associationsTemp[i].nx * sinw + cp_associationsTemp[i].ny * cosw + dty - cp_associationsTemp[i].ry;tmp2*=tmp2;
	error = error+ tmp1+tmp2;
}

error_ratio = error / error_k1;

#ifdef INTMATSM_DEB
	printf("<err,errk1,errRatio>=<%f,%f,%f>\n estim=<%f,%f,%f>\n",
	error,error_k1,error_ratio, estim_cp.x,estim_cp.y, estim_cp.tita);
#endif

// ----
/* Check the exit criteria */
/* Error ratio */
if (fabs(1.0-error_ratio)<=params.error_th ||
	(fabs(estim_cp.x)<params.errx_out && fabs(estim_cp.y)<params.erry_out
	&& fabs(estim_cp.tita)<params.errt_out) ){
	numConverged++;
}
else
	numConverged=0;

//--
/* Build the solution */
composicion_sis(&estim_cp, &motion2, solucion);
motion2=*solucion;
error_k1=error;

/* Number of iterations doing convergence (smooth criterion of convergence) */
if (numConverged>params.IterSmoothConv)
	return 1;
else
	return 0;
}
Exemple #16
0
/*
 Função que ordena o Ranking da Metrica apontada pelo parâmetro, utilizando a 
 chave de ordenação o campo pontuacao do TAD Ranking. O método de ordenação 
 utilizado é HeapSort.
*/
void ordenaRankingMetrica(Metrica* metrica)
{
	// Ordena o vetor de Ranking conforme o HeapSort
	heapsort(metrica->vetorRanking, metrica->quantidadeElementos);
}
int main(void){
    int *vetor1,*q, *vetorinverso;
	  int cont, cont2, media, cont3, cont4;
    float tempo1, tempo2, tempo3, tempo4, iteracoes=10;
  	int MAX=100000;
  	clock_t Ti, Tf;
  	float DeltaT;

	  srand((unsigned)time(NULL));
    printf("tamanho,quicksort_ordenacao,quicksort_jaordenado,quicksort_decrescente,mergesort_ordenacao,mergesort_jaordenado,mergesort_decrescente,heapsort_ordenacao,heapsort_jaordenado,heapsort_decrescente,shellsort_ordenacao,shellsort_jaordenado,shellsort_decrescente\n");
    for(cont=0;cont<10;cont++){
      vetor1=malloc(sizeof(int) * MAX);
      vetorinverso=malloc(sizeof(int) * MAX);
      tempo1=0;
      tempo2=0;
      tempo3=0;
      tempo4=0;
      for(cont2=0;cont2<10;cont2++){
        for(cont3=0;cont3<MAX;cont3++){
          vetor1[cont3]=rand() % MAX;
         }
        q=copiavetor(vetor1,MAX);
        Ti=clock();
        quickSort(q,0,MAX-1);
        Tf=clock();
        DeltaT=Tf-Ti;
        DeltaT=DeltaT/1000;
        tempo1=tempo1+DeltaT;
        free(q);

        q=copiavetor(vetor1,MAX);
        Ti=clock();
        merge_sort(q,MAX-1);
        Tf=clock();
        DeltaT=Tf-Ti;
        DeltaT=DeltaT/1000;
        tempo2=tempo2+DeltaT;
        free(q);

        q=copiavetor(vetor1,MAX);
        Ti=clock();
        heapsort(q,MAX-1);
        Tf=clock();
        DeltaT=Tf-Ti;
        DeltaT=DeltaT/1000;
        tempo3=tempo3+DeltaT;
        free(q);

        q=copiavetor(vetor1,MAX);
        Ti=clock();
        shellSort(q,MAX-1);
        Tf=clock();
        DeltaT=Tf-Ti;
        DeltaT=DeltaT/1000;
        tempo4=tempo4+DeltaT;

      }
      cont4=0;
      for(cont3=MAX-1;cont3>=0;cont3--){
          vetorinverso[cont4]=cont3;
          cont4++;
         }
      printf("%d,",MAX);
      //printf("quicksort;");
      Ti=clock();
      quickSort(q,0,MAX-1);
      Tf=clock();
      DeltaT=Tf-Ti;
      DeltaT=DeltaT/1000;
      printf("%f,",(tempo1/iteracoes));
      printf("%f,",DeltaT);
      free(q);
      q=copiavetor(vetorinverso,MAX);
      Ti=clock();
      quickSort(q,0,MAX-1);
      Tf=clock();
      DeltaT=Tf-Ti;
      DeltaT=DeltaT/1000;
      printf("%f,",DeltaT);

      //printf("mergesort\n");
      Ti=clock();
      merge_sort(q,MAX-1);
      Tf=clock();
      DeltaT=Tf-Ti;
      DeltaT=DeltaT/1000;
      printf("%f,",tempo2/iteracoes);
      printf("%f,",DeltaT);
      free(q);
      q=copiavetor(vetorinverso,MAX);
      Ti=clock();
      merge_sort(q,MAX-1);
      Tf=clock();
      DeltaT=Tf-Ti;
      DeltaT=DeltaT/1000;
      printf("%f,",DeltaT);

      //printf("heapsort\n");
      Ti=clock();
      heapsort(q,MAX-1);
      Tf=clock();
      DeltaT=Tf-Ti;
      DeltaT=DeltaT/1000;
      printf("%f,",tempo3/iteracoes);
      printf("%f,",DeltaT);
      free(q);
      q=copiavetor(vetorinverso,MAX);
      Ti=clock();
      heapsort(q,MAX-1);
      Tf=clock();
      DeltaT=Tf-Ti;
      DeltaT=DeltaT/1000;
      printf("%f,",DeltaT);

      //printf("shellsort\n");
      Ti=clock();
      shellSort(q,MAX-1);
      Tf=clock();
      DeltaT=Tf-Ti;
      DeltaT=DeltaT/1000;
      printf("%f,",tempo4/iteracoes);
      printf("%f,",DeltaT);
      free(q);
      q=copiavetor(vetorinverso,MAX);
      Ti=clock();
      shellSort(q,MAX-1);
      Tf=clock();
      DeltaT=Tf-Ti;
      DeltaT=DeltaT/1000;
      printf("%f,",DeltaT);
      free(q);
      free(vetor1);
      free(vetorinverso);
      MAX=MAX+100000;
      printf("\n");
    }
    return 0;
}
int main(int argc, char *argv[])
{ 
  struct bildinfo geoinfo;        /* alles zum Bildbearbeiten aus dem Header*/ 
  struct bildattribut{
      char name[128];          /* Struktur, um fuer jedes Bild die geo-  */
      int doy;                 /* zu verarbeiten                         */
      double time;
      double gamma; 
      double f;
      double dec;
      double EOT;
      double lon_sun;  
      unsigned char headline[HDL];  /* Recordlaenge fuer "echte" Groesse    */ 
      short int **imagedata;  /* matrix; msg data are assigned to imagedata */
      byte **Bimagedata; /* Matrix, mfg data are assigned to Bimagedata */
  };
  struct bildattribut bildfolge[BILDANZ]; /* Zahl der Listenelemente: Monat = BILDANZ */

  int rho_max=0;           /* maximale Reflektivitaet bei Met-8 Bildern   */
                             /* Cosinuskorrektur                            */
  double GMT;                /* Abscannzeitpunkt                            */
  int quiet=0;               /* Bildschirminformationen ?                   */
  int accm;                  /* parameter for MFG GMT calculation           */
  int lin, col;              /* Zaehlvariablen fuer Zeile und Spalte        */
  int n=0;                   /* Anzahl der verarbeiteten  Bilder            */
  int decide;                /* ausserhalb der Erde oder nicht              */
  double lat,lon;            /* latitude and longitude in radians !         */
  double corr;               /* normalisierte Radianz                       */
  double coszen;             /* Cosinus des Zenitwinkels                    */
  /* ---> SELFCALIBRATION: declarations */
  /* RM May 2008: added file pointer frhomax,fstatrho */
  FILE *out_image,*list,*f,*frhomax,*fstatrho;
  /* RM May 2008: fper and kend1 is needed for the caclulation of the percentile */
  short int *fper = NULL;  
  int kend1=0;
  /* RM May 2008: added averaged angles used for the caclculation of the scatter angle scata */
  float msza=0;  /* average of the solar zenith angle over time and space within the calibration region */
  float mazi=0;  /* average of the solar azimuth angle over time and space within the calibration region */
  float msatazi=0; /* average of the sat azimuth angle .... */
  float msatzen=0; /* average of the satellite zenith angle */
  float scata=0;   /* the mean scattering angle */
  double satazi, satzen;     /* geometry of MSG, satellite zenith and azimuth  */
  float r2d=180.0/3.1416;
  float esd;      /* variable for the geometric correction of rho_max */
  float dpos=0.0; /* dpos is the position of Meteosat relativ to lon=0, West is negative, East positive */
  /* <--- SELFCALIBRATION declarations */

                              /* Dateinamen von Bildern                      */ 
  char out_imagefile[160],groundpathname[128],
       cloudpathname[128],bild[128],bildpathname[128];            
  short int **out;           /* Matrix fuer die Ausgabewerte       	    */
  short int reflectivity_vector[BILDANZ]; 
  short int min, hour;

  char *cp;                         /* temporaere Werte                     */
  char zeitname[4];                 /* temporaerer ASCII-String der Zeit    */
         
  long zahl,anzahl;
  double cloudindex ;
  double db_hours_per_line; /* added in order to caclulate the timeoffset */
  char *channel="MFGVIS"; /* added, currently hard wired, shoul be provided via heliosat call once the thermal irradiance is
			included */
  short int MFG=1; /* added, currently hard wired, should be provided via heliosat call, once the routine is successfully tested for 
                   MFG and MSG !! */
  int i,k,laenge;
  char quite='\0';
  short int sig_ground, sig_shadow=0; /* width of distribution of cloudfree pixels 
                                        and shaded pixels */
  /* sig_shadow is zero, the shadow module will not be used, it is too slow and probably not needed if 
  the fuzzy logic Heliosat version is used*/

  short int(temp);
  float doffset=0; /* the dark/space offset of the instrument */

  slope=(BYTE_MAX-BYTE_MIN)/(CLOUDI_MAX-CLOUDI_MIN);
  y_intercept=BYTE_MAX-CLOUDI_MAX*slope;                   /* DEFINE */
  *out_imagefile = '\0';
  for(i = 0;i <= BILDANZ;i++){*bildfolge[i].name = '\0';}
  

/*** optionale Argumente von der command line lesen... ***/

  if (argc<4)             /* wenn nicht mindestens zwei opt.Parameter.. */
    exit_print_usage();   /* .. dann schliesse das Programm */

  for (i=1; i<argc; i++)  /* fuer alle Argumente..                          */
  {
    cp=argv[i];
    if (*cp!='-' && *cp!='/') /* pruefe ob Argument mit '-' oder '/' beginnt */
    {
      fprintf(stderr,"bodenalbedo: no option specified (%s)\n",cp);
      exit_print_usage();
    }
    cp++;
    if (*(cp+1))            /* pruefe ob an uebernaechster Stelle ein Blank  */
    {
      fprintf(stderr,"bodenalbedo: missing blank. Usage: -%c <arg>\n",*cp);
      exit(1);
    }
    *cp=(char) tolower((int) *cp); /* es wird nicht zwischen Klein- und      *
				    * Grossschreibung unterschieden          */

    if (*cp=='l') list=fopen(argv[++i],"rt");
    else if (*cp=='b') strcpy(bildpathname,argv[++i]);
    else if (*cp=='c') strcpy(cloudpathname,argv[++i]);
    else if (*cp=='g') strcpy(groundpathname,argv[++i]);
    /* ---> SELFCALIBRATION dpos instead of sig_ground !!! */
    else if (*cp=='s') dpos=atof(argv[++i]); /*dpos instead of sig_ground, see  program header for details */
    else if (*cp=='z') MFG=atoi(argv[++i]); 
    /* MFG instead of sig_shadow MFG=1: MFG data expected MFG=0: MSG data */ 
    else if (*cp=='q') quite='q';
    else {
      fprintf(stderr,"bodenalbedo: unknown option: %s\n",cp);
      exit_print_usage();
    }
  }
  if (dpos != 0.0) 
  {printf("Meteosat position not at longitude=0 ! Please check -s in the heliosat call & set it to 0 if Met is at lon=0 \n");}

  if(MFG==1)
  {printf("assume MFG image data as input !! \n please check if you realy use MFG: -z has to be 0 for MSG \n");}
  else{
      printf("assume MSG image data as input !! \n please check if you realy use MSG: -z has to be 1 for MFG \n");
  }


 /* oeffnen aller Dateien, die in Liste stehen, Header auswerten, Matrizen zuweisen */
 zahl=0;
 while(!feof(list) && anzahl < BILDANZ )
       /* CaP - inserting the limit of BILDANZ to avoid coredumps*/
       /* ||  anzahl < BILDANZ )        */
 { 
   anzahl=zahl;
   fscanf(list,"%s\r",bildfolge[anzahl].name);
   strcpy(bild,bildpathname);
   strcat(bild,"/");
   strcat(bild,bildfolge[anzahl].name);
   
   if(!quite)printf("%d %s\n",anzahl,bild);
   
   read_xpif_header(HDL,bild,&bildfolge[anzahl].headline[0]); /* store header for output XPIF-images */
   
   
    if(HDL==256)
    {
     bildfolge[anzahl].headline[11]=(unsigned char) 0;          /* no additional headers wanted !      */
    }
    if (MFG==1)
    { 
      bildfolge[anzahl].Bimagedata=read_xpif_to_Bmatrix(HDL,bild,&geoinfo);
      bildfolge[anzahl].imagedata=smatrix(0,geoinfo.nrlines-1,0,geoinfo.nrcolumns-1);
      /* RM 17.07.09: dark offset and snanning time is different for MFG and MSG */
      db_hours_per_line=(25./geoinfo.nrlines/60.);
      doffset=4.5*4;
      for (lin = 0;lin < geoinfo.nrlines;lin++) {  /* change type and rotate the image, afterwards free bmatrix */
	  for(col = 0;col < geoinfo.nrcolumns;col++){ 
	      /* temp=(short int)bildfolge[anzahl].Bimagedata[geoinfo.nrlines-lin-1][geoinfo.nrcolumns-col-1]; */
	      /* correct if old openMTP converter is used */
	  bildfolge[anzahl].imagedata[lin][col]=4*(short int)bildfolge[anzahl].Bimagedata[geoinfo.nrlines-lin-1][geoinfo.nrcolumns-col-1]; 
	  /* correct if new openMTP to XPIF converter is used */
          /* bildfolge[anzahl].imagedata[lin][col]=4*(short int)bildfolge[anzahl].Bimagedata[lin][col]; */

	  /* multiplication with factor 4 needed in order to have only one BYTE MAX definition */  
           /* (short int)bildfolge[anzahl].Bimagedata[lin][col]; */
	      /* (short int)bildfolge[anzahl].Bimagedata[geoinfo.nrlines-lin-1][geoinfo.nrcolumns-col-1]; */
            /*       printf("i,j,temp= %d %d %d",lin, col, temp); */
	  }
      }
      free_bmatrix(bildfolge[anzahl].Bimagedata,0,geoinfo.nrlines-1,0,geoinfo.nrcolumns-1); 
	/* bildfolge[anzahl].Bimagedata=read_xpif_to_Bmatrix(HDL,bild,&geoinfo); */ 
    } 
    else{
	bildfolge[anzahl].imagedata=read_xpif_to_matrix(HDL,bild,&geoinfo);
	db_hours_per_line=(12./geoinfo.nrlines/60.);
	doffset=51;
    }
    printf("Iam here 1 %d %d \n",geoinfo.nrlines, geoinfo.nrcolumns); 
    bildfolge[anzahl].doy=geoinfo.doy;
    hour=geoinfo.aq_time /100;
    min=fmod(geoinfo.aq_time,100);
    bildfolge[anzahl].time=hour+min/60.0;
    bildfolge[anzahl].EOT=equation_of_time(bildfolge[anzahl].doy,&bildfolge[anzahl].gamma,&bildfolge[anzahl].f,&bildfolge[anzahl].dec);
    zahl++; 
  } 
 n=anzahl;    
 printf ("n= %d \n",n);
 /*  printf("doy is %04d %04d \n",geoinfo.doy, geoinfo.aq_time );   
    printf("nrs is %d %d %d %d \n",geoinfo.nrlines,geoinfo.nrcolbig,geoinfo.nrcolumns, geoinfo.nrlines );
    printf("nrs is %d %d %d %d \n",geoinfo.line_off,geoinfo.col_off,geoinfo.nav_lres, geoinfo.nav_cres );  */
  
 /* orig out=smatrix(0,geoinfo.nrlines-1,0,geoinfo.nrcolbig-1); RM 24.02->*/
  out=smatrix(0,geoinfo.nrlines-1,0,geoinfo.nrcolumns-1);
 
 /***  Normalize images   ---------------------------------------- ***/
 
 /* allocate memory for fper 42610*/
/* fper = malloc(45000 * (n+1) * sizeof(short int));
 if(fper == NULL)
 {
     fprintf(stderr, "not enough memory for array fper, needed for automatic calibration \n");
     exit;
     } */
  /* CaP - allocating only 2 bytes for now. Using realloc later in the loop below (line 719).
The former memory allocation (previous line) causes severe memory errors and 
program crashes */
 
  /* --> SELFCALIBRATION: initial allocation of field needed for the percentiles */
  fper = malloc(sizeof(short int));
  /* <-- */
  printf("Iam here 2 \n");
  accm=0;
 for (lin = 0;lin < geoinfo.nrlines;lin++)   /* fuer alle Zeilen */
 { 
/* 12.10.09 included new lines for the calculation of GMT. Now MFG and MSg can be processed */
 /* old, orig for MSG GMT=bildfolge[anzahl].time+timeoffset(geoinfo.nav_lres,geoinfo.line_off,lin,15); */
     /* GMT : Abscannzeitpunkt dieser Zeile bestimmen */
      /* 17.07.09 fixed GMT bug, accm needed to consider that two subsequent lines are scanned in || */
     accm=accm+abs((lin-1)%2); 
     GMT=bildfolge[anzahl].time+(double)lin*db_hours_per_line; 
     /* printf("now here vv \n");*/
    if ((strcmp(channel,"MFGVIS")==0) && MFG==1)
     {  /* CaP 29.04.2009 - in the vis imagery adjacent lines are scanned in couples */
	 GMT=bildfolge[anzahl].time+(double)(accm-1)*db_hours_per_line;
	 /*  printf("GMT,accm= %f %d \n",GMT ,accm); */
     }
     /* orig  GMT=bildfolge[anzahl].time+timeoffset(geoinfo.nav_lres,geoinfo.line_off,lin,15); */  
     /* GMT=bildfolge[anzahl].time+timeoffset(geoinfo.nav_lres,geoinfo.line_off,lin,15);  */

     for (k = 0 ;k <= n;k++)  /* fuer alle Bilder */
     {
	 /* fuer Abscannzeit dieser Zeile und jeden Tag den Sonnenstand bestimmen */
	 bildfolge[k].lon_sun=(12.0-GMT-(bildfolge[k].EOT/60.0))*15*(PI/180.0);
     }
     /* printf("ere re re %d \n",k); */
     for(col = 0;col < geoinfo.nrcolumns;col++)  /* fuer alle Spalten */
     { 
         if(MFG==1){
	     decide=geoloc(lin,col,geoinfo.nrlines,&lat,&lon);
         }
         else{
	decide=geomsg(geoinfo.nav_cres,geoinfo.nav_lres,geoinfo.col_off,geoinfo.line_off,lin,col,&lat,&lon);
	 }
         /* if (decide == 0){
         printf("the geoloc i,j,lat,lon %d %d %f %f \n", lin, col,lat*180/pi,lon*180/pi);
         } */
	     /* orig decide=geomsg(geoinfo.nav_cres,geoinfo.nav_lres,geoinfo.col_off,geoinfo.line_off,lin,col,&lat,&lon); */

	 /* ---> SELFCALIBRATION: calculation of additional angles */
         /* RM Jul 2008: added equations for the calculation of satellite zenith and azimuth 
		  !! it is assumed that the satellite is at lat=lon=0
		  h=42164.0 height of geostationary Satellite */
	 satazi = atan(sin(lon-dpos/r2d)/tan(lat)); /* rm 072008 modified formular, covers all positions of Meteosat now */
	 /* old satzen = fabs(atan(sin(lat) * h/(cos(lat) * h - R_E))); */
    satzen=90/r2d-atan((cos(dpos/r2d-lon)*cos(lat)-0.1512)/sqrt(1-pow(cos(dpos/r2d-lon),2)*pow(cos(lat),2)));     /* <--- SELFCALIBRATION: calculation of additional angles */         
	 if (decide==0)
	 {
	     for(k = 0 ;k <= n;k++)  /* fuer alle Bilder */
	     {
		 corr=0;
		 coszen=cos_zenit(lat,lon,bildfolge[k].dec,bildfolge[k].lon_sun);
		 if(coszen>0.02)
		     corr = (int)((bildfolge[k].imagedata[lin][col]-doffset)/coszen); /* orig 51 instead of doffset */
		 corr = mini(corr,BYTE_MAX);
		 corr = maxi(corr,BYTE_MIN); 
		 bildfolge[k].imagedata[lin][col] = corr;
		 /* RM 20.11.07:  automatic calculation of rho_max starts, sort vector content according 
		    to the value, in ascending order using heapsort, Numerical Recipies in C 
		    the 95 percentil * 1.1 is than the desired rhomax value */
		 /* ---> SELFCALIBRATION: Calculate the percentile and additional angles
                         needed for the calculation of the scatter angle */
	  if(lat > -0.92 && lat < -0.8 && lon  < (-0.01 + dpos/r2d) && lon > (-0.262+dpos/r2d)) /* -0.436*/     
		/* RM 072008: added +dpos in order to shift the reference region for Meteosat-East
		dpos=position of Meteosat relative to lon=0 in degree, west is negative */  
               {
		
		fper[kend1]=(short int)bildfolge[k].imagedata[lin][col]; /* assign values within region to fper */
		kend1=kend1+1;
		/* calculate the mean angles as basis for the caclulation of the scatter angle, 
		   needed for the geometric correction of rhomax */
		fper = realloc(fper,(kend1+1)*sizeof(short int));
		msza=((kend1-1)*msza+acos(coszen))/kend1; 
		mazi=((kend1-1)*mazi+azimuth(lat,lon,bildfolge[k].dec,acos(coszen),bildfolge[k].lon_sun))/kend1;
		msatazi=((kend1-1)*msatazi+satazi)/kend1;
		msatzen=((kend1-1)*msatzen+satzen)/kend1;
	        }
            /* <--- end of SELFCALIBRATION: Calculate the percentile and additional angles
                         needed for the calculation of the scatter angle */
	     }
	 }
         if (decide==1){
	     out[lin][col] = (int) 0;
	     for(k=1;k<=n;k++){
		 /*  if(geoinfo.nrlines<200){doffset=doffset+ bildfolge[15].imagedata[lin][col];} */
		     bildfolge[k].imagedata[lin][col] = 0;
	     }
	 }
     }
 }
 printf("doffset= %f \n", doffset);
 printf("now I am here \n"); 

 /* ---> SELFCALIBRATION: sorting the fper field and assignment of the percentiles */
 heapsort(kend1, fper); /* order the counts */
 int p1=(int)(0.1*(kend1+1));
 int p3=(int)(0.3*(kend1+1));
 int p5=(int)(0.5*(kend1+1));
 int p7=(int)(0.7*(kend1+1));
 int p8=(int)(0.8*(kend1+1));
 int p9=(int)(0.9*(kend1+1));
 int pm=(int)(0.95*(kend1+1));
 /* <--- SELFCALIBRATION: sorting the fper field and assignment of the percentiles */
 /* ---> SELFCALIBRATION: empirical correction of anisotropy for rho_max */
 /* RM 28.05.08 empirical correction for scatter angle effect, so far formula only proven for 3 - 33 degree,
    RM 30.07.08 implemented new formula, correction works from 3-70 degree (scata), but probably only for 
             the reference regions and not everywhere, above scattering angle of 32 the uncertainty of
             the geometric corrections is significnat higher */
 scata=scatt_angle(msza, mazi, msatzen, msatazi);
 /* added new correction for rho_max, seems that the dominant effect comes from the
   sza dependent change of the cloud albedo, the clouds seems to reflect pretty well
   isotropic for a given SZA and rel AZA lower than 60 degree
   the correction formula results from a linear fit (gnuplot) applied to a 
   2.5 year time series for all slots with SZA>60 */
   if (msza*r2d > 80.0 && msza*r2d <0.0) esd=1.0;  /* gcor =1 for SZA>80 and <0*/
   else
   {esd=1+0.0017*(45.0-msza*r2d); }

 /* <--- SELFCALIBRATION: empirical correction of anisotropic cloud reflection for rho_max */
 /* ---> SELFCALIBRATION: Open and write the output files for information  related to  the 
         self calibration approach */
  fstatrho=fopen("rhostat.out","a") ;
 fprintf(fstatrho, "# kend1= %d doy= %d hour= %d min = %d \n",kend1,geoinfo.doy, hour,min);
 fprintf(fstatrho, " gcor= %f msza= %f mazi= %f satazi= %f satzen= %f scattangle= %f rhomax %f pm= %d \n", esd, msza*r2d, (mazi)*r2d, msatazi*r2d, msatzen*r2d, scata*r2d, fper[pm]*esd*1.1, fper[pm]);
 fprintf(fstatrho, "# ESD= %f rho(10,30,50,70,80,90,95)= %d  %d %d %d %d %d  %d rhomax %f \n",esd,fper[p1],fper[p3],fper[p5],fper[p7], fper[p8],fper[p9],fper[pm], fper[pm]*esd*1.1);
   if (hour==13 && min==0)
   {
       frhomax=fopen("rhomax.out","w");  /* RM 072008 changed r+ to w, r+ does not work properly on my machine */
       rho_max=fper[pm]*esd*1.1;
       fprintf(frhomax, "%d \n", rho_max);
       fprintf(fstatrho,"## The noon rho_may is %d \n",rho_max );
       fclose(frhomax); 
   }
   else
   {
       /* if((frhomax=fopen("rhomax.out","r")) == NULL) */
       if(file_exists("rhomax.out")) 
       {
           frhomax=fopen("rhomax.out","r");
	   fscanf(frhomax, "%d", &rho_max);	   
	   fprintf(fstatrho,"# Use noon rhomax from rhomax.out %d \n",rho_max );
	   printf("Use noon rhomax from rhomax,out %d \n",rho_max );
	   fclose(frhomax); 
       }
       else
       {
	   fprintf(fstatrho,"# WARNING Cannot open rhomax file, hence instead of the noon rhomax that of the actual slot is used,which might lead to higher uncertainty.\n");
	   rho_max=(int)fper[pm]*esd*1.1;
	   fprintf(fstatrho,"# Use rhomax of actual slot %d \n",rho_max );
	   /*fclose(frhomax);*/
       }  
   }
   sig_ground=(short int)(0.035 * rho_max);
   fprintf(fstatrho,"#  sig_ground =%d \n \n",sig_ground );
   fclose(fstatrho);
   free(fper);
   /* <--- SELFCALIBRATION: Open and write the output files for information  related to  the 
      self calibration approach */  
   printf("Finished normalizing images and automatic calibration \n");
 /*
  *  Grundalbedo and Cloud Index  ----------------------------------------
  */

 for (lin = 0;lin < geoinfo.nrlines;lin++)   /* fuer alle Pixel (Zeilen ... */
 {
   for(col = 0; col < geoinfo.nrcolumns; col++)  /* ... und Spalten)            */
   { 
     for(k = 0; k<=n; k++)
     {
       /* copy all values to a vector, from these values ground albedo will de determined 
          reflectivity_vector contains all reflectivity values for one location */
        reflectivity_vector[k]=bildfolge[k].imagedata[lin][col]/bildfolge[k].f;
	/* /f correct for earth sun-distance **/
     } 
	 /* calculation of ground albedo: 
	    out[lin][col]contains ground albedo
	    reflectivity_vector contains cloud index values */
     out[lin][col]=groundreflectivity_and_cloudindex(&reflectivity_vector[0], n, sig_ground, sig_shadow, rho_max);
     for(k = 0; k<=n; k++)
     { 
       /* copy all cloud index values from vector back to matrix */
       bildfolge[k].imagedata[lin][col]=reflectivity_vector[k];

     }   
   }
  }
 
/***********************************************************************
  *  Ausgeben aller Bilder und Freisetzung des Speicherplatzes...
 ***********************************************************************/ 
  
  /* Bodenalbedonamen zusammensetzen  */
  /* RM changed the naming of the reflectance files, mothly means for every slot are calculated and has to be saved,
     with the old naming they are  overriden */ 
     strcpy(out_imagefile,groundpathname);
     strcat(out_imagefile,"/");
     sprintf(zeitname,"%04d",geoinfo.aq_time);
     strncat(out_imagefile,bildfolge[1].name,6); /* added string for year and month */
     /*strncat(out_imagefile,zeitname,4);*/
     strcat(out_imagefile,zeitname);
     /* printf("out_imagefile = %s bildfolge.name= %s\n",out_imagefile, bildfolge[1].name); */ 
     if(HDL==256)strcat(out_imagefile,"hhmm.REF"); 
     if(HDL==260)strcat(out_imagefile,"hhmm.REF.X260"); 
  /* Grundalbedo speichern */
     
   printf("nrbytes= %d",geoinfo.nrbytes) ;
  if (!(out_image=fopen(out_imagefile,"wb"))) 
     exit_no_write(out_imagefile);
    
  if (MFG==1) 
  {geoinfo.nrbytes=geoinfo.nrbytes*2;}   /* dangerous, only for testing */

   fwrite(&bildfolge[1].headline[0],HDL,1,out_image);    

   /* orig fwrite(&out[0][0],geoinfo.nrcolbig*geoinfo.nrlines*(long)geoinfo.nrbytes,1,out_image);  
   fclose(out_image);
   free_smatrix(out,0,geoinfo.nrlines-1,0,geoinfo.nrcolbig-1); */
   fwrite(&out[0][0],geoinfo.nrcolumns*geoinfo.nrlines*(long)geoinfo.nrbytes,1,out_image);  
   fclose(out_image);
   free_smatrix(out,0,geoinfo.nrlines-1,0,geoinfo.nrcolumns-1);
  
  for(k=0;k<=n;k++)             
  {  
     strcpy(out_imagefile,cloudpathname);
     strcat(out_imagefile,"/");
     strncat(out_imagefile,bildfolge[k].name,strlen(bildfolge[k].name)-4);
     if(HDL==256)strcat(out_imagefile,"CI.XPIF");
     if(HDL==260)strcat(out_imagefile,"CI.X260"); 
     if (!(out_image=fopen(out_imagefile,"wb"))) 
         exit_no_write(out_imagefile);
     fwrite(&bildfolge[k].headline[0],HDL,1,out_image);   
     /*  orig
	 fwrite(&bildfolge[k].imagedata[0][0],geoinfo.nrcolbig*geoinfo.nrlines*(long)geoinfo.nrbytes,1,out_image);  */
   
     /* memcpy(void *dest, const void *src, size_t n);*/
     bildfolge[k].Bimagedata=bmatrix(0,geoinfo.nrlines-1,0,geoinfo.nrcolumns-1);
     for (lin = 0;lin < geoinfo.nrlines;lin++) {  
	 for(col = 0;col < geoinfo.nrcolumns;col++){ 
	     bildfolge[k].Bimagedata[lin][col]=(byte)(bildfolge[k].imagedata[lin][col]/4);
	 }
     }
	 fwrite(&bildfolge[k].Bimagedata[0][0],geoinfo.nrcolumns*geoinfo.nrlines,1,out_image);
	 free_bmatrix(bildfolge[k].Bimagedata,0,geoinfo.nrlines-1,0,geoinfo.nrcolumns-1);
	 fclose(out_image);
	 free_smatrix(bildfolge[k].imagedata,0,geoinfo.nrlines-1,0,geoinfo.nrcolumns-1); /* orig geoinfo.nrcolbig-1 */
  }

  return(0);
}
Exemple #19
0
/*
 *worker thread to sort a portion of the set of numbers
 * */
void * thr_fn(void *arg) {
    long idx = (long)arg;
    heapsort(&nums[idx],TNUM,sizeof(long),complong);
    pthread_barrier_wait(&b);
    return ((void*)0);
}
Exemple #20
0
int DArray_heapsort(DArray *array, DArray_compare cmp)
{
    return heapsort(array->contents, DArray_count(array), sizeof(void *), cmp);
}
Exemple #21
0
void 
heap_sort (int *v, int n)
{
    heapsort (n, v - 1);
}
Exemple #22
0
void lib_hsort(int *values, int n) {
  heapsort(values, n, sizeof(values[0]), mycompare);
}
Exemple #23
0
std::vector<Coord> AStar( std::vector< std::vector< int > > grid, Point start, Point end )
{

	//The current 'focal' point.
	Point *cur;

	//The open and closed lists.
	std::vector< Point* > closed;
	std::vector< Point* > open;

	//Start by adding the starting position to the list.
	open.push_back( &start );

	//Just so it knows whether or not to try and reconstruct a path.
	bool error = true;

	while( open.size() > 0 )
	{

		//The current point is the first entry in the open list.
		cur = open.at(0);

		if( cur->getPos() == end.getPos() )
		{

			error = false;
			break;

		}

		//Add in all the neighbors of the current point.
		for( int y = -1; y <= 1; y++ )
		{

			for( int x = -1; x <= 1; x++ )
			{

				int curX = cur->getPos().x+x;
				int curY = cur->getPos().y+y;

				int movCost = 10;

				//If it is a diagonal, make it cost 14 instead of 10.
				if( (y == -1 && x == -1)||
					(y ==  1 && x == -1)||
					(y == -1 && x ==  1)||
					(y ==  1 && x ==  1))
				{

					movCost = 14;
					//continue;

				}

				Coord temp( curX, curY );
				bool make = true;

				//If it is outside the range of the map, continue.
				if( curY >= grid.size() || 
					curX >= grid.size() )
				{

					continue;
				}

				/*

				These two loops are to check whether or not the point's neighbors already exist.
				This feels really sloppy to me. Please tell me if there is a better way.

				*/
				for( int i = 0; i < open.size(); i++ )
				{

					if( temp == open.at(i)->getPos() )
					{

						make = false;
						break;

					}

				}

				for( int i = 0; i < closed.size(); i++ )
				{

					if( temp == closed.at(i)->getPos() )
					{

						make = false;
						break;

					}

				}

				//If the point in the map is a zero, then it is a wall. Continue.
				if( (grid.at(temp.x).at(temp.y) == 0 ) ||
					( temp.x<0 || temp.y < 0 ) )
				{

					continue;

				}

				//If it is allowed to make a new point, it adds it to the open list.
				if( make )
				{

					int gScore = cur->getCost();
					int hScore = manhattan( end.getPos(), Coord( curX, curY ) );
					int tileCost = grid[curX][curY];
					int fScore = gScore+hScore+tileCost+movCost;

					open.push_back( new Point( curX, curY, fScore, cur ) );

				}
		
			}

		}

		//It then pushes back the current into the closed set as well as erasing it from the open set.
		closed.push_back( cur );
		open.erase( open.begin() );

		//Heapsort works, guranteed. Not sure if it's a stable sort, though. From what I can tell that shouldn't matter, though.
		open = heapsort( open );

	}

	std::vector<Coord> path;

	if( error )
	{

		return path;

	}

	//Reconstruct a path by tracing through the parents.
	while( cur->getParent() != nullptr )
	{

		path.push_back( cur->getPos() );
		cur = cur->getParent();
		
	}

	path.push_back( cur->getPos() );

	return path;

}
Exemple #24
0
void sort(short int *values, unsigned char n) {
	if(n != 0)
		heapsort(values, n);
}
// This method fills the symmetric sparse structure
// so that the matrix is not any more in upper or lower
// triangular form.
void CSRdouble::fillSymmetric()
{
  int nonzeros;
  int  n        = this->nrows;
  int* prows    = this->pRows;
  int* pcols    = this->pCols;
  double* pdata = this->pData;

  vector<vector<double> > vA(n);
  vector<vector<int> >    vcols(n);

  int i;
  for (i = 0; i < n; i++)
  {
    for (int index = prows[i]; index < prows[i+1]; index++)
    {
      int j = pcols[index];

      vcols[i].push_back(j);
      double a_ij = pdata[index];
      vA[i].push_back(a_ij);

      // this is the j column in the i-th row; now we need to find the 
      // i-th column in the j-th row; If it is there we do nothing; if
      // not then we need to add it 
      if (i != j)
      {
        bool found = false;
        for (int k = prows[j]; k < prows[j+1]; k++)
        {
          int col = pcols[k];
          if (col == i)
          {
            found = true;
            break;
          }
        }

        if ( !found )
        {
          //cout << "The matrix is not Structurally Symmetric\n";
          vcols[j].push_back(i);
          vA[j].push_back(a_ij);
        }
      }
    }
  }

  int* ia = new int[n+1];
  ia[0]   = 0;
  for (i = 0; i < n; i++)
  {
    ia[i+1] = ia[i] + vcols[i].size(); 
  }

  nonzeros   = ia[n];
  int* ja    = new int[nonzeros];
  double* a  = new double[nonzeros];

  for (i = 0; i < n; i++)
  {
    int index = ia[i];
    int entries = vcols[i].size();
    for (int j = 0; j < entries; j++)
    {
      ja[index + j] = vcols[i][j];
      a[index + j]  = vA[i][j];
    }

    if (entries > 1)
      heapsort(entries, &ja[index], &a[index]);
  }

  delete[] pRows;
  delete[] pCols;
  delete[] pData;

  make(n, n, nonzeros, ia, ja, a);
  matrixType = NORMAL;
}
Exemple #26
0
struct node *delmin(struct node *f[],int n)
{
	heapsort(f,n);

	return f[n-1];
}
Exemple #27
0
int main(int argc, char ** argv){
 long ierr, n, ntot;
 int myid, mysize;
 long icheck,isort,iprint;
 double t1, t2, tdiff;
 long * ia = (long *) malloc(isize*sizeof(long));
 long * index = (long *) malloc(isize*sizeof(long)); 
 memset(ia,0,isize);
 memset(index,0,isize);

//**********************************************************************
//  Initialization
//**********************************************************************
t1 = omp_get_wtime();
isort = 0;
iprint = 1;
ntot = isize;
//**********************************************************************
// Initialize MPI and Get myrank:
//**********************************************************************
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&mysize);
//**********************************************************************
//  Get mysize:
//**********************************************************************

MPI_Comm_rank(MPI_COMM_WORLD,&myid);
//**********************************************************************
//  worker task
//**********************************************************************
long elements_to_print[30];
if (myid == 0){
  printf("myid = %d of total size = %d\n",myid,mysize);

//**********************************************************************
// open file and read ia array
//***********************************************************************/
  printf("reading input from file hw7.in\n");
  readfile("hw7.in",ia);
// =================== IMPORT THE FILE hw7.in ==========================


  printf("File opened successfully. Reading input values\n");
//  read (1,*,err = 30) ia
//  prlong *,isize,' longeger values read successfully'
//  go to 40
//
//  30 prlong *,'Error reading input values --- Stopping!'
//  go to 999

//**********************************************************************
// calling heapsort
//**********************************************************************
  printf("myid = %d; calling heapsort\n",myid);
  heapsort(ia, ntot, isort);

/***********************************************************************
// check that data are in ascending order
***********************************************************************/
  icheck = 0;
  if(isort == 0){
//=================== ascending ========================================
    for(n = 1; n < ntot;++n){
 
      if (ia[n] < ia[n-1]){
        printf("Error in sorted order at n = %d\n",n);
	icheck = 1;
      };
    };
  }else{
//==================== descending ======================================
    for(n = 1; n < ntot;++n){
      if (ia[n] > ia[n]){
        printf("Error in sorted order at n = %d \n",n);
	icheck = 1;
      };
    };
  };

/***********************************************************************
// termination test
***********************************************************************/
  if(icheck == 0){
     printf("Array sorted correctly\n");
  }else{
     printf("Array sorted incorrectly\n");
  };
/***********************************************************************
//  prlong sorted indices
***********************************************************************/

 long element_count=0;
  if(iprint == 1){
/***********************************************************************
//  prlong 1st 10 elements
***********************************************************************/
    for(n = 0; n< 10;++n){
      //elements_to_prlong.push_back(ia[index[n]]);
      elements_to_print[element_count] = ia[n];
      ++element_count;
    };
/***********************************************************************
//  prlong middle 10 elements
***********************************************************************/
    for(n = ((ntot/2)-5); n< ((ntot/2)+5);++n){
      //elements_to_prlong.push_back(ia[index[n]]);
      elements_to_print[element_count] = ia[n];
      ++element_count;
    }
/***********************************************************************
//  prlong last 10 elements
***********************************************************************/
    for(n = (ntot-10); n < ntot;++n){
      //elements_to_prlong.push_back(ia[index[n]]);
      elements_to_print[element_count] = ia[n];
      ++element_count;
    }; 
 }; 
/*****************************************************
 get total time
******************************************************/
t2 = omp_get_wtime();
tdiff = t2 - t1;
printf("\tPrintng 1st 10 elements\n");
 long j;
 for(j=0;j<10;++j){
   printf("\t%d, \t%d\n",j+1,elements_to_print[j]);
 }
 printf("\tPrintng middle 10 elements\n");
  for(j=10;j<20;++j){
    printf("\t%d, \t%d\n",j+(ntot)/2-15+1,elements_to_print[j]);
 }
 printf("\tPrintng last 10 elements\n");
 for(j=20;j<30;++j){
   printf("\t%d, \t%d\n",j+ntot-30+1,elements_to_print[j]);
 }
printf("Total wall clock time = %f  (secs) --- Stopping!\n",tdiff);
}else{
//**********************************************************************
//**********************************************************************
//  worker tasks
//**********************************************************************
//**********************************************************************
  printf("myid = %d of total size = %d\n",myid,mysize);
} 

 
//
// terminate MPI
//
MPI_Finalize();
//
//3000 format (1x,'Calling hsort: isort,iprint =',2(1x,i5))
//3001 format (5x,'Before sort: printing ia with',i12,' elements')
//3002 format (5x,'Final: printing ia with',i12,' elements')
//3003 format (5x,'Printing 1st 10 elements')
//3004 format (5x,'Printing middle 10 elements')
//3005 format (5x,'Printing last 10 elements')
};
int main() {

    heapsort(); 

    return(0);
};
Exemple #29
0
// This function build a node of the kdtree with the
// points indexed by pidx with length "len"
// sortidx is a pre-computed array using the heapsort
// algorithm above
int KDTree::build_kdtree(int **sortidx, int dim,
                                   int *pidx, int len, AABB &currentBB)
{
	static const Vec3 BufferOffset( KD_SPLIT_BUFFER_SIZE, KD_SPLIT_BUFFER_SIZE, KD_SPLIT_BUFFER_SIZE );
	AABB b1, b2;
	int ncnt = nodeMemCnt;
	struct KDTreeNode *node = node_alloc();
	node->bounds.Set( currentBB.m_Bounds[0] - BufferOffset, currentBB.m_Bounds[1] + BufferOffset );
		
	node->axis = dim;
	if (len <= m_KDCellSize &&
		m_KDCellSize == 1 ) 
	{
		node->leftIdx = -1;
		node->rightIdx = -1;
		node->pntidx = pidx[0];
		node->key = 0;
		node->bounds.Set( currentBB.m_Bounds[0] - BufferOffset, currentBB.m_Bounds[1] + BufferOffset );
		//add objects to this node
		if( m_NodeCreationCallBack )
		{
			(*m_NodeCreationCallBack)( node );
		}
		return ncnt;
	}
  
	 // If not, we must make a node
	int pivot = -1;
	int lcnt = 0, rcnt = 0;
	int *larray, *rarray;

	// Find the pivot (index of median point of available
	// points on current dimension).

	// If heapsorting the current list of points is quicker than
	// iterating through all the points, just do that instead 
	// (heapsort if of order n*log(n)
	// This test could probably use some fine tuning
	if((double)len*log((double)len) < npoints) {
		heapsort(dim,pidx,len);
		larray = pidx;
		rarray = pidx+len/2;
		pivot = pidx[len/2];
		lcnt = len/2;
		rcnt = len/2 + (len%2==0 ? 0 : 1);
	}
	else 
	{
		// Use the previously calculated sort index
		// to make this a process linear in npoints
		// This gets a little confusing, but it works.
		// Sortidx:: sortidx[dim][idx] = val 
		// idx = the index to the point
		// val = the order in the array
		int *parray = workArr;
		
		// Setting parray to -1 indicates we are not using 
		// the point
		for (int i = 0; i < npoints; i++)
			parray[i] = -1;
		// Populate "parray" with the points that we
		// are using, indexed in the order they occur
		// on the current dimension
		for (int i = 0; i < len; i++)
			parray[sortidx[dim][pidx[i]]] = pidx[i];
		int cnt = 0;
		larray = int_alloc(len/2+1);
		rarray = int_alloc(len/2+1);
		
		// The middle valid value of parray is the pivot,
		// the left go to a node on the left, the right
		// go to a node on the right.
		for (int i = 0; i < npoints; i++) {
			if (parray[i] == -1)
				continue;
			if (cnt == len / 2) {
				pivot = parray[i];
				rarray[rcnt++] = parray[i];
			} else if (cnt > len / 2)
				rarray[rcnt++] = parray[i];
			else
				larray[lcnt++] = parray[i];
			cnt++;
			if(cnt>len)
				break;
		}
	}

	if (len <= m_KDCellSize &&
		m_KDCellSize > 1 ) 
	{
		node->leftIdx = -1;
		node->rightIdx = -1;
		if( m_KDCellSize > 1 )
		{
			for( int i = 0; i < len; i++ )
			{
				node->fattyCellData.push_back( pidx[ i ] );
			}
		}
		node->pntidx = pivot;
		node->key = 0;
		node->bounds.Set( currentBB.m_Bounds[0] - BufferOffset, currentBB.m_Bounds[1] + BufferOffset );
		//add objects to this node
		if( m_NodeCreationCallBack )
		{
			(*m_NodeCreationCallBack)( node );
		}
		return ncnt;
	}

	// Create the node
	node->pntidx = -1;
	node->key = points[pivot*ndim+dim] + KEY_EPSILON;
	//calculate bounding boxes
	if( m_NodeCreationCallBack )
	{
		b1 = b2 = currentBB; //b1 is for left, b2 for right
		//split on the x axis
		int realDim = dim%ndim;
		if( realDim == 0 ){
			b1.m_Bounds[1].x = node->key; //set tmax bounds of left bb to be new split point
			b2.m_Bounds[0].x = node->key; //set tmin bounds of right bb to be new split point 
		}else if( realDim == 1 )
		{
			b1.m_Bounds[1].y = node->key; //set tmax bounds of left bb to be new split point
			b2.m_Bounds[0].y = node->key; //set tmin bounds of right bb to be new split point 
		}else if( realDim == 2 )
		{
			b1.m_Bounds[1].z = node->key; //set tmax bounds of left bb to be new split point
			b2.m_Bounds[0].z = node->key; //set tmin bounds of right bb to be new split point 
		}
	}
	// Create nodes to the left
	node->leftIdx = 
		build_kdtree(sortidx, (dim + 1) % ndim, larray, lcnt, b1);
	
	// Create nodes to the right
	node->rightIdx = 
		build_kdtree(sortidx, (dim + 1) % ndim, rarray, rcnt, b2);

  return ncnt;
}				// end of build_kdtree
Exemple #30
0
typedef unsigned long long my_sorted_t;
typedef std::vector<my_sorted_t> my_vector_t;

static struct
{
	const char *name;
	std::function<void (my_vector_t &)> fun;
}
g_tests[] =
{
	{"STL vector sort", [] (my_vector_t &v) {
		std::sort (v.begin (), v.end ());
	}},
	{"Vector heapsort", [] (my_vector_t &v) {
		heapsort (v);
	}},
	{"STL qsort", [] (my_vector_t &v) {
		qsort (v.data (), v.size (), sizeof *(v.data ()),
			int_compare<my_sorted_t>);
	}},
	{"8-bit radixsort", [] (my_vector_t &v) {
		radixsort_8 (v.data (), v.size (), sizeof *(v.data ()));
	}}
};


template<typename T, typename U>
static int
measure (const std::vector<T> &v, const std::vector<T> &ref, U f)
{