int main(int v, char **c) {

    //srand(( unsigned )time(NULL));

    inputCorretto(v, c);

    char ch;
    double *a;
    int len = atoi(c[2]);

    fprintf(stdout, "Vuoi generare l'array a random (y/n)? ");
    fscanf(stdin, "%c", &ch);
    if( ch == 'y') {
        a = generateArray(RANDOM, DOUBLE, len, 100);
        for( int i = 0; i<len; i++)
            a[i] = a[i]/100;
    }
    else
        a = generateArray(NOTRANDOM, DOUBLE, len);

    printArray(a, len, "double");

    bucketSort( a, len );

    return 0;
}
Exemple #2
0
void dpVectorAdd::init(){
	dataParameters.push_back(Asize);
	dataNames.push_back("nElements");
	
	// Allocate and initialize host arrays 
	srcA = (float *)malloc(sizeof(cl_float) * Asize);
	srcB = (float *)malloc(sizeof(cl_float) * Asize);
	dst = (float *)malloc(sizeof(cl_float) * Asize);
	generateArray(srcA, Asize);
	generateArray(srcB, Asize);
}
Exemple #3
0
// returns the pointer to the list; NULL if list not created
PCB_p createPCB(char* name, int newPid, int newPriority, int theInterruptSimulator,
	int thePcValue, State theState) {
	if (newPriority > 15 || newPriority < 0) {
		printf("Error 1212123: Priority must be 0 - 15. PCD not Created.");
	}
	//struct control_block_type testing;
	PCB_p pcb = malloc(sizeof(struct PCB));
	// if allocation was successful
	if (pcb != NULL) {

            strcpy(pcb->name, name);
            pcb->pid = newPid;
            pcb->priority = newPriority;
            pcb->interrupt_simulator = theInterruptSimulator;
            pcb->pc = thePcValue;
            pcb->currentState = theState;

            //New stuff
            //pcb->max_pc = ?   jowy added  (do we need a new parameter?)
            pcb->creation = getTheCurrentTime();
            pcb->terminate = (rand() % 11) +1;
            pcb->term_count = 0;
            generateArray(pcb->IO_1_traps, pcb->IO_2_traps);

	}
	return pcb;
}
// ----------------------------------------------------------------------------
int main(int argc, char** argv) {
  DBG("[Lesson 1]: Sortings: Standard sort 1");

  int A[SIZE], B[SIZE], C[SIZE];
  generateArray(A, SIZE);
  copy(A, B, SIZE);
  copy(A, C, SIZE);

  sort::insertion(A, SIZE);
  sort::mergesort(B, SIZE);
  sort::quicksort(C, SIZE);

  if (!equal(A, B, SIZE)) {
    ERR("Insertion vs Mergesort NOT equal result!");
  } else {
    INF("OK");
  }
  if (!equal(A, C, SIZE)) {
    ERR("Insertion vs Quicksort NOT equal result!");
  } else {
    INF("OK");
  }
  if (!equal(B, C, SIZE)) {
    ERR("Mergesort vs Quicksort NOT equal result!");
  } else {
    INF("OK");
  }

  DBG("[Lesson 1]: Sortings: Standard sort 1 [END]");
  return 0;
}
Exemple #5
0
int main(int argc, char *argv[])
{
	int i;
	int  n;

	// loop {number of iterations} [number of threads]

	if(argc<2) {
		printf("Usage: sumcomp {array size} [number of threads]\n");
		exit(1);
	}
	
	n = atoll(argv[1]);
	printf("Debug: array size = %d \n",n);

	if(argc==3) {
		p = atoi(argv[2]);
		assert(p>=1);
		printf("Debug: number of requested threads = %d\n",p);
	}

	omp_set_num_threads(p);

	#pragma omp parallel
	{
		assert(p==omp_get_num_threads());
		//printf("Debug: number of threads set = %d\n",omp_get_num_threads());

		int rank = omp_get_thread_num();
		printf("Rank=%d: my world has %d threads\n",rank,p);
	}  // end of my omp parallel region

	double time = omp_get_wtime();

	// 1. generate the array
	//
	//
	int *a=NULL;
	a = generateArray(n);

	//dispArray(a,n);

	// 2. compute sum using reduce
	computeSum(a,n);


	
	time = omp_get_wtime() - time;
	printf("Total time = %f seconds \n ", time);

	return 0;
}
Exemple #6
0
int main()
{
    srand(time(NULL));
    int *array= NULL, size = 20;
    array=(int*)malloc(size*sizeof(int));

    generateArray(array, size, 0, 99);
    outputArray(array, size);
    sortBuble(array, size,less);
    outputArray(array,size);

    free(array);
    array=NULL;
    return 0;
}
Exemple #7
0
	//main function definition
int main()
{
	SeedRand(); //seeds the rand() with system time
	int size=6;
	struct input* ip = NULL;
	struct data** dt = NULL;

	ip=generateArray(size);	//input structure is generated and initialized
	dt=generateDataArray(size);	//generates and initializes data structure
	findMax(dt,size,ip);	//calls findMax function
	printData(dt,size);	//printData function called

				//frees the allocated space from the heap
	freeallpointers(dt,size,ip);
	return 0;	//successful termination of program
}
// ----------------------------------------------------------- 
// FUNCTION  Heap Sort : (heap)                          
//    Sorts m random integers using the heap sort                            
// PARAMETER USAGE :                                           
//    m : The number of integers to sort using heap sort                
// FUNCTION CALLED :                                           
//    generateArray: It creates a random array of size m, of ints
//    printArray: Prints the array given to it. For both sorted and unsorted array
//    sortArray: Sorts the array given to it
//----------------------------------------------------------- 
int heap( long int *m ) {
    char buffer[256];
    int heapArray[*m], i;
  
    sprintf( buffer, "   Heap Sort Process Started\n" );
    write( 1, buffer, strlen( buffer ) );    

    generateArray( heapArray, *m );
    printArray( heapArray, *m, 0 );   

    sortArray( heapArray, *m );
    printArray( heapArray, *m, 1 );   

    sprintf( buffer, "   Heap Sort Process Exits\n" );
    write( 1, buffer, strlen( buffer ) );    
}
Exemple #9
0
int main(int argc, char *argv[]){
  int i, j;
	int N;
  char name[128];
	N = 50000000;
	float *Aout, *Ain;
	
	Aout = (float*) malloc(N*sizeof(float));
	if (!Aout){
		fprintf(stderr,"error in Aout malloc");
	}
	
	Ain = (float*) malloc(N*sizeof(float));
	if (!Ain){
		fprintf(stderr,"error in Ain malloc");
	}
	
	printf("total Data: %0.3f Megabytes\n", (float) N*sizeof(float)/1048576);
	generateArray(Ain, N);
	
  //starting up opencl
  cl_device_id devices[MAXDEVICES];
  cl_platform_id platforms[MAXPLATFORMS];
  unsigned int num_devices, num_platforms;
  
  clGetPlatformIDs(MAXPLATFORMS, platforms, &num_platforms);
  printf("number of platforms found: %d\n", num_platforms);
  for (i = 0; i < num_platforms; i++){
    clGetPlatformInfo(platforms[i], CL_PLATFORM_NAME, sizeof(name), name, NULL);
    clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_ALL, MAXDEVICES, devices, &num_devices);
   //list devices available on platform
    printf("platform %s with %d devices\n", name, num_devices);
    for (j = 0; j < num_devices; j++){
      clGetDeviceInfo(devices[j], CL_DEVICE_NAME, sizeof(name), name, NULL);
      printf("\tdevice %d %s\n", j, name);
			memTest(platforms[i], devices[j], Ain, Aout, N);
    }
  }
  
  return 0;
}
Exemple #10
0
int main (int argc, char *argv[]){

	int proc_id,procs_num;
	int iloop;
	int A[totalSize];
	int a[chunkSize];

	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
	MPI_Comm_size(MPI_COMM_WORLD, &procs_num);

	if (proc_id == 0) {
		generateArray("A",A,totalSize);
		printArray("A",A,totalSize,0);
	}

	MPI_Scatter(A, chunkSize, MPI_INT, 
				a, chunkSize, MPI_INT, 
				0, MPI_COMM_WORLD);

	printArray("a",a,chunkSize,proc_id);

	MPI_Finalize();
}
Exemple #11
0
int main()
{
    static int array[100];
    int initilized = 0;
    int sorted = 0;
    
    int loop = 1;
    while(loop == 1)
    {
        int choice;
        printf("Välj opperation:\n");
        printf("  1. Generera en ny Talföljd.\n");
        printf("  2. Sortera arrayen.\n");
        printf("  3. Min/Max/median.\n");
        printf("  4. Sök.\n");
        printf("  8. Print array.\n");
        printf("  9. Exit.\n");
        scanf("%d", &choice);
        
        switch(choice)
        {
            case 1:
                array = generateArray(array);
                initilized = 1;
                sorted = 0;
                printArray(array);
                break;
            case 2:
                if(initilized == 1)
                {
                    array = sortArray(array);
                    sorted = 1;
                    printArray(array);
                }
                else
                {
                    printf("Ej giltig Talföljd.\nGenerera en ny först.\n");
                }
                break;
            case 3:
                if(sorted == 1)
                {
                    valueOperations(array);
                }
                 else
                {
                    printf("Ej giltig Talföljd.\nGenerera en ny Sortera först.\n");
                }
                break;
            case 4:
                if(sorted == 1)
                {
                    int value;
                    printf("Vilket värde vill ni söka efter?\n");
                    scanf("%d", &value);
                    searchArray(array, value);
                }
                 else
                {
                    printf("Ej giltig Talföljd.\nSortera först.\n");
                }
            case 8:
                printArray(array);
                break;
            case 9:
                loop = 0;
                break;
            default:
                printf("Ej giltigt kommando.\n");
                break;
        }
            
    }
    return 1;
}
Exemple #12
0
// ----------------------------------------------------------------------------
int main(int argc, char** argv) {
    DBG("[Lesson 1]: Sortings: Standard sort 2");

    bool flag = true;

    while (flag) {
        size_t size = std::rand() % 65536 + 1;
        int* A = new int[size];
        int* B = new int[size];
        int* C = new int[size];
        int* D = new int[size];

        generateArray(A, size);
        copy(A, B, size);
        copy(A, C, size);
        copy(A, D, size);

        sort::insertion(A, size);
        sort::mergesort(B, size);
        sort::quicksort(C, size);
        std::sort(D, D + size);

        bool accumulate_1 = equal(A, B, size);
        bool accumulate_2 = equal(A, C, size);
        bool accumulate_3 = equal(B, C, size);
        bool accumulate_4 = equal(D, C, size);

        if (!accumulate_1) {
            ERR("Insertion vs Mergesort NOT equal result!");
            print(A, size);
            printf("\n");
            print(B, size);
            flag = false;
        }
        if (!accumulate_2) {
            ERR("Insertion vs Quicksort NOT equal result!");
            print(A, size);
            printf("\n");
            print(C, size);
            flag = false;
        }
        if (!accumulate_3) {
            ERR("Mergesort vs Quicksort NOT equal result!");
            print(B, size);
            printf("\n");
            print(C, size);
            flag = false;
        }
        if (!accumulate_4) {
            ERR("Standard sort vs Quicksort NOT equal result!");
            print(D, size);
            printf("\n");
            print(C, size);
            flag = false;
        }

        if (flag) {
            INF("OK: %zu", size);
        }

        delete [] A;
        delete [] B;
        delete [] C;
        delete [] D;
    }

    DBG("[Lesson 1]: Sortings: Standard sort 2 [END]");
    return 0;
}