int main(){ int array[ARRAY_SIZE]={}; int i=0; float seconds; clock_t end ,start; InitializeArray(array); printf("Unsorted array\n\n"); DisplayArray(array); HEAP heap = heapify(array,ARRAY_SIZE); //for(i=0;i<ARRAY_SIZE;i++){printf("%d at %d \t",heap->hArray[i],i+1); } start = clock(); HeapSort(heap,array); end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; //printf("\n\n"); printf("\nSorted array\n\n"); DisplayArray(array); printf("\n\nTime taken for sort= %f sec\n",seconds); return 0; }
IntArray *Executor::CreateIntArray(const numeric::Width *width, int array_length, fe::ArrayInitializer *array_initializer) { IntArray *array = IntArray::Create(width, array_length); InitializeArray(array, array_initializer); return array; }
//------------------------------------------------------------------------------ bool CvDatabaseUtility::PopulateArrayByExistence(int*& pArray, const char* szTypeTableName, const char* szDataTableName, const char* szTypeColumn, const char* szFilterColumn, const char* szFilterValue) { InitializeArray(pArray, MaxRows(szTypeTableName), -1); std::string strKey = "_PABE_"; strKey.append(szTypeTableName); strKey.append(szDataTableName); strKey.append(szFilterColumn); Database::Results* pResults = GetResults(strKey); if(pResults == NULL) { char szSQL[512]; sprintf_s(szSQL, "select %s.ID from %s inner join %s on %s = %s.Type where %s = ?", szTypeTableName, szDataTableName, szTypeTableName, szTypeColumn, szTypeTableName, szFilterColumn); pResults = PrepareResults(strKey, szSQL); if(pResults == NULL) return false; } if(!pResults->Bind(1, szFilterValue, false)) { CvAssertMsg(false, GetErrorMessage()); return false; } int idx = 0; while(pResults->Step()) { pArray[idx++] = pResults->GetInt(0); } pResults->Reset(); return true; }
int InitializeType(TYP *tp) { int nbytes; switch(tp->type) { case bt_byte: nbytes = initbyte(); break; case bt_char: case bt_enum: nbytes = initchar(); break; case bt_short: nbytes = initshort(); break; case bt_pointer: if( tp->val_flag) nbytes = InitializeArray(tp); else nbytes = InitializePointer(); break; case bt_long: nbytes = initlong(); break; case bt_struct: nbytes = InitializeStructure(tp); break; default: error(ERR_NOINIT); nbytes = 0; } return nbytes; }
Object *Executor::CreateMemoryObject(const numeric::Width *width, int array_length, fe::ArrayInitializer *array_initializer) { Object *obj = ArrayWrapper::NewIntArrayWrapper(thr_->GetVM(), array_length, width); IntArray *memory = ArrayWrapper::GetIntArray(obj); InitializeArray(memory, array_initializer); return obj; }
int main() { int Array[ARRAY_SIZE] ={}; int j=0,k=1; int noElements; float seconds[30]={}; clock_t end ,start; printf("\nSorting a %d Elements of Integers.following are the time in Each Trial\n",ARRAY_SIZE); printf("\nThreshold is %d in Each Trial\n",THRESHOLD); while(j<30){ InitializeArray(Array); //printf("\t\t::::::::::::::::Unsorted array:::::::::::::::::::\n\n"); //DisplayArray(Array); int last = sizeof(Array)/sizeof(Array[0])-1; start = clock(); //printf("Threshold = %d \n",threshold); quickInSort(Array, 0, last,THRESHOLD); end = clock(); seconds[j] = (float)(end - start) / CLOCKS_PER_SEC; //printf("\t\t::::::::::::::::Sorted array:::::::::::::::::::\n\n"); //DisplayArray(Array); printf("Time taken %d : run = %f\n",j,seconds[j]); j++; } float avgsum=0; int i; for(i=0;i<30;i++){ avgsum += seconds[i]; } float avg=avgsum/30; printf("avg Time taken for 30 runs = %f\n",avg); return 0; }
int main() { int Array[ARRAY_SIZE] ; int j=0; int myInt; int noElements; float seconds[30]={}; clock_t end ,start; printf("\nSorting %d Elemetns using merge Sort\n\n",ARRAY_SIZE); while(j<30){ InitializeArray(Array); //printf("\t\t::::::::::::::::Unsorted array:::::::::::::::::::\n\n"); //DisplayArray(Array); noElements = sizeof(Array)/sizeof(Array[0]); start = clock(); mergeSort(Array,noElements); end = clock(); seconds[j] = (float)(end - start) / CLOCKS_PER_SEC; //printf("\t\t::::::::::::::::Sorted array:::::::::::::::::::\n\n"); //DisplayArray(Array); printf("Time taken %d : run = %f sec\n",j,seconds[j]); j++; } float avgsum=0; int i; for(i=0;i<30;i++){ avgsum += seconds[i]; } float avg=avgsum/30; printf("avg Time taken for 30 runs = %f\n",avg); return 0; }
/*main*/ int main(void) { enum state now; now = Any_state; int x=0; int ch=0; InitializeArray();/*init array*/ ch=getchar(); do{ now=(katastaseis[now])(ch); }while ((ch=getchar())!=EOF); printf("/n"); return 0; }
int main() { printf("\nSorting %d Elemetns using merge Sort\n\n",ARRAY_SIZE); int Array[ARRAY_SIZE] ; InitializeArray(Array); printf("\t\t::::::::::::::::Unsorted array:::::::::::::::::::\n\n"); DisplayArray(Array); printf("\n\n" ); int noElements; noElements = sizeof(Array)/sizeof(Array[0]); clock_t start = clock(); mergeSort(Array,noElements); clock_t end = clock(); float seconds = (float)(end - start) / CLOCKS_PER_SEC; printf("\t\t::::::::::::::::Sorted array:::::::::::::::::::\n\n"); DisplayArray(Array); printf("\n\n\t\t::::::::::::::::Time taken - %f sec:::::::::::::::::::\n\n",seconds); return 0; }
int main() { //Some variables //Seed the random number generator (do only once!) srand(time(NULL)); int * p = 0; //Pointer to DMA'd int p = (int *) malloc(sizeof(int)); if(!p) { printf ("Memory Allocation Error. Your computer sucks."); return -1; } //If I got here, I got memory *p = 42; printf("The answer to life, the universe and everything is %d\n",*p); //Give my memory back if (p) free(p); p = 0; //You can reuse pointers if you're cool (and careful!) //A pointer to int can point to an int, or an array of ints p = MakeArray(ARRAYSIZE); printf("Uninitialized array:\n"); PrintArray(p,ARRAYSIZE); InitializeArray(p,ARRAYSIZE); printf("Initialized array:\n"); PrintArray(p,ARRAYSIZE); //Put away your toys! if (p) free(p); //Free don't care how big it is. p = 0; return 0; }
//------------------------------------------------------------------------------ bool CvDatabaseUtility::PopulateArrayByValue(int*& pArray, const char* szTypeTableName, const char* szDataTableName, const char* szTypeColumn, const char* szFilterColumn, const char* szFilterValue, const char* szValueColumn, int iDefaultValue /* = 0 */, int iMinArraySize /* = 0 */) { int iSize = MaxRows(szTypeTableName); InitializeArray(pArray, (iSize<iMinArraySize)?iMinArraySize:iSize, iDefaultValue); std::string strKey = "_PABV_"; strKey.append(szTypeTableName); strKey.append(szDataTableName); strKey.append(szFilterColumn); strKey.append(szValueColumn); Database::Results* pResults = GetResults(strKey); if(pResults == NULL) { char szSQL[512]; sprintf_s(szSQL, "select %s.ID, %s from %s inner join %s on %s = %s.Type where %s = ?", szTypeTableName, szValueColumn, szDataTableName, szTypeTableName, szTypeColumn, szTypeTableName, szFilterColumn); pResults = PrepareResults(strKey, szSQL); if(pResults == NULL) return false; } if(!pResults->Bind(1, szFilterValue, false)) { CvAssertMsg(false, GetErrorMessage()); return false; } while(pResults->Step()) { const int idx = pResults->GetInt(0); const int value = pResults->GetInt(1); pArray[idx] = value; } pResults->Reset(); return true; }
int main() { //declare function variables int i,k,j,l; int n=0; int pass=0; double numArray[]; int minout[ARRAYLEN]; int maxout[ARRAYLEN]; double meanout[ARRAYLEN]; double ntimesn[ARRAYLEN]; double nfacout[ARRAYLEN]; double mean=0; double sizesquare=0; double nfactorial, nsq; //seed the generator srandom(RNG_SEED); //introduction message printf("Project 1, Created by: Alec Webb, Description: Solves the nqueens problem using permutations\n"); printf("---------------------------------------------------------------\n"); for(j=4; j<=ARRAYLEN; j++){ //start n loop int solutionFound=0; //used to determine first run or not int nCounter=0; //used to count number of runs for 10 solutions int pncount=0; //used to calulate current number of runs for max min functions int current=0; //for max min functions int minimum=0; //for max min comparisons int maximum=0; //for max min comparisons n=j; //set size of array nsq=j; //set size for calculations for(k=0; k<LOOPTIME; k++){ //find 10 solutions pass=0; //to continue after a first match is found pncount = nCounter; //for maxmin calc while(pass==0) { InitializeArray(numArray, n); //call initialize method randperm(numArray, n); //call randperm function pass = checkboard(numArray, n); //check the permutation nCounter++; //total# of runs } current = nCounter-pncount; //for max min,current run time if(pncount==0) //to account for a run that has not occured { //avoids min being set to 0 minimum = maximum = current; } else { minimum = min(minimum, current); //compare maximum = max(maximum, current); //compare } solutionFound++; //indicate first solution has been found if(solutionFound <=1) //handles the first and only first solution { displayboard(numArray, n); //print the solution found printf("---------------------------------------------------------------\n"); printf(" "); for(i=0; i<n; i++){ //print the numerical solution found printf("%-3.0lf", numArray[i]); } printf(": Solution for board size %d\n", n); printf("---------------------------------------------------------------\n"); } } //calculate and store relevent values mean = nCounter/10; //determine mean sizesquare = nsquared(nsq,n); //determine n^n nfactorial = factorial(n); //determine n! //stores the values for printing minout[j-4] = minimum; maxout[j-4] = maximum; meanout[j-4] = mean; ntimesn[j-4] = sizesquare; nfacout[j-4] = nfactorial; }//end n loop //the following prints out the results of the 10 runs for each n printf("size min max mean size**size size!\n"); printf("---------------------------------------------------------------\n"); for(l=0; l<NUMBEROFBOARDS; l++) { printf("%4d %8d %10d %12.1e %12.1e %12.1e\n", (l+4), minout[l], maxout[l], meanout[l], ntimesn[l], nfacout[l]); } return 0; }//end main
int main() { int xPos = (XGRID - 1)/2; int yPos = YGRID - 2; int xBull = 0; int yBull = 0; int WallArr[XGRID]; InitializeArray(WallArr, 1, XGRID); int BulletCounter = XGRID * 2; char Player = 'X'; char Wall = '#'; char Bullet = '^'; char PInput; printf("Controls:\n\nW: Shoot\nA: Left\nD: Right\nEnter: Execute Move(s)\n"); printf("\nPress Enter to start.\n\n"); getchar(); system("cls"); while (1) { DrawGrid(XGRID, YGRID, xPos, yPos, xBull, yBull, Player, Wall, Bullet, WallArr); printf("\n"); if (SumArray(WallArr, XGRID) < 3) { printf("You Win!\n\n"); break; } else if (BulletCounter < 1) { printf("You Lose!\n\n"); break; } scanf("%c",&PInput); PInput = toupper(PInput); switch (PInput) { case 'W': xBull = xPos; ShootingGrid(XGRID, YGRID, xPos, yPos, xBull, yBull, Player, Wall, Bullet, WallArr); WallArr[xPos] = 0; BulletCounter--; break; case 'A': if (xPos > 1) xPos--; break; case 'D': if (xPos < XGRID - 2) xPos++; break; } system("cls"); } return 0; }
//===----------------------------------------------------------------------===// // Allocate an array that is 2x of the current size, updating the mask (for // rehash), resize threshold, and element count, and then rearrange all existing // elements in the old array to their new locations // // This function will invalidate all pointers on the old hash table // So do not call this until all states have been cleared //===----------------------------------------------------------------------===// void OAHashTable::Resize(HashEntry **entry_p_p) { // Make it an assertion to prevent potential bugs PELOTON_ASSERT(NeedsResize()); LOG_DEBUG("Resizing hash-table from %llu buckets to %llu", (unsigned long long)num_buckets_, (unsigned long long)num_buckets_ << 1); // Double the size of the array num_buckets_ <<= 1; // Recompute bucket mask (same as in init()) bucket_mask_ = num_buckets_ - 1; // The threshold for resizing also doubles resize_threshold_ <<= 1; // Allocate the new array char *new_buckets = static_cast<char *>(malloc(entry_size_ * num_buckets_)); // Set it all to status code FREE InitializeArray(reinterpret_cast<HashEntry *>(new_buckets)); // This is the pointer we are tracking // If it is not free, then during rehashing we will update its // value through the pointer to be the new location in the resized array HashEntry *entry_p = *entry_p_p; // We use this count to check end condition. This serves as a faster path than // iterating over all buckets in the array. uint64_t processed_count = 0; // This points to the current entry being processed char *current_entry_char_p = reinterpret_cast<char *>(buckets_); while (processed_count < num_valid_buckets_) { // This is meaningless - just to make compiler happy HashEntry *current_entry = reinterpret_cast<HashEntry *>(current_entry_char_p); // Ignore entries that are not occupied by a valid hash key and value if (!current_entry->IsFree()) { // We have processed one valid entry processed_count++; // The trick here is that we do not need to recompute the hash since it // stays the same as long as the key does not change // So just re-mask the hash value and get the index in the new array uint64_t new_index = current_entry->hash & bucket_mask_; // This is the pointer to the new entry char *new_entry_char_p = new_buckets + new_index * entry_size_; // Probe the array until we find a free entry while (!reinterpret_cast<HashEntry *>(new_entry_char_p)->IsFree()) { new_index++; new_entry_char_p += entry_size_; // If we have reached the end of the array just wrap back if (new_index == num_buckets_) { new_index = 0; new_entry_char_p = new_buckets; } } // If the current entry is not free and is what we are looking for, // then return in the argument the new location of that entry // the gist behind this is to track a certain key by its entry address // since we have guaranteed a given key has only one entry address // This should happen only once if (entry_p == current_entry) { *entry_p_p = reinterpret_cast<HashEntry *>(new_entry_char_p); } // Copy everything, including is_free flag, hash value and key-value // to the new free entry we just found PELOTON_MEMCPY(new_entry_char_p, current_entry_char_p, entry_size_); } // No matter we ignore an entry or not this has to be done current_entry_char_p += entry_size_; } // Free the old array after probing of all elements, and then update free(buckets_); buckets_ = reinterpret_cast<HashEntry *>(new_buckets); }
int main() { int threshold=SIZE+5; int Array1[SIZE] ={}; int Array2[SIZE] ={}; int j=0; int noElements; float secondsI[TRIALS]={}; float secondsQ[TRIALS]={}; clock_t end ,start; while(j<TRIALS){ InitializeArray(Array1,SIZE); CopyArray(Array1,Array2,SIZE); //printf("Unsorted array\n\n"); //DisplayArray(Array1,SIZE); //DisplayArray(Array2,SIZE); int last = sizeof(Array1)/sizeof(Array1[0])-1; if(j==0)printf("Threshold = %d \n",threshold); start = clock(); //quickSort(Array, 0, last); quickInSort(Array1, 0, last,threshold); end = clock(); secondsI[j] = (float)(end - start) / CLOCKS_PER_SEC; last = sizeof(Array2)/sizeof(Array2[0])-1; threshold=threshold-10; start = clock(); quickInSort(Array2, 0, last,threshold); end = clock(); secondsQ[j] = (float)(end - start) / CLOCKS_PER_SEC; //printf("Sorted array\n\n"); //DisplayArray(Array1,SIZE); //DisplayArray(Array2,SIZE); //printf("\n\n"); j++; } float avgsumI=0; float avgsumQ=0; int i; for(i=0;i<TRIALS;i++){ avgsumI += secondsI[i]; } for(i=0;i<TRIALS;i++){ avgsumQ += secondsQ[i]; } float avgI=avgsumI/TRIALS; float avgQ=avgsumQ/TRIALS; printf("using QuickInSort algo with bigger threshold than size Avg Time taken for %d runs = %f sec\n",TRIALS,avgI); printf("using QuickInSort algo with lower threshold than size(without Insertion sort) Avg Time taken for %d runs = %f sec\n",TRIALS,avgQ); return 0; }