void mySort(int *a, int l, int r, char(*str)[300], char *tempStr) { int i = l, j = r, mid = a[(r + l) >> 1]; while (i <= j) { while (a[i] < mid) i++; while (a[j] > mid) j--; if (i <= j) swap(a, str, tempStr, i++, j--); } if (i < r) mySort(a, i, r, str, tempStr); if (l < j) mySort(a, l, j, str, tempStr); }
void Merge_Sort(int B[],int N) { int i; int l; int p; int flag = 0; for(l = 2; l<=N; l*=2){ p = l; while(p < N){ if(B[p-1] > B[p]){ flag = 1; break; } p = p + 2 * l; } if(flag) break; } l = l * 2; for(i = 0; i<N; i = i + l){ if(i+l >= N) l = N-i; mySort(B+i,l); } }
void Manager::query() { int temp = 0, t = 0, counter = 0; char str[30][300]; int partKey[30]; char tempStr[300]; fscanf(testInStream, "%d", &t); queryNum = t; start = clock(); while (t--) { fscanf(testInStream, "%d", &temp); counter = 0; int hashKey = getHash(temp, index->getGlobalDepth()); int pageId = index->getPageId(hashKey); int location = buffer->ifPageExist(pageId); if (location == -1) { location = buffer->choseByClock(); buffer->readOutPage(location, pageId); } Page* p = buffer->getPage(location); int size = p->getRecordNumber(); for (int i = 0; i < size; i++) { if (getKey(p->getRecord(i)) == temp) { strcpy(str[counter], p->getRecord(i)); partKey[counter] = getPartKey(str[counter]); counter++; } } mySort(partKey, 0, counter - 1, str, tempStr); for (int i = 0; i < counter; i++) fprintf(testOutStream, "%s\n", str[i]); fprintf(testOutStream, "-1\n"); } buffer->closeFile(); index->closeFile(); fclose(inStream); fclose(testOutStream); fclose(testInStream); finish = clock(); printf("\n*** Query Finished ***\nCost %fs totally, that is %fmin.\n", (double)(finish - start) / CLOCKS_PER_SEC, (double)(finish - start) / CLOCKS_PER_SEC / 60.0); printf("Query Speed: %f query per second.\n", (double)queryNum / ((double)(finish - start) / CLOCKS_PER_SEC)); printf("Total Buffer I/O times: %d\n", buffer->iotimes); printf("Total Index I/O times: %d\n", index->iotimes); }
int main(void){ int arr[10] = {-1 , 2 , -89 , 56 , 8 , 1 , 45 ,-5 , 6 , 6} , min , max , i , j; int sum=0,sh,sl; long int prod; mySort(arr,10); for(i=0 ; i < 10 ; i++){ sum=sum+arr[i]; printf("%d ",arr[i]); } printf("\n\n"); sl = secondLowest(arr,10); sh = secondHighest(arr,10); prod = posProd(arr,10); printf("min : %d , max : %d, sum: %d , secHigh: %d , secLow: %d \n",arr[0],arr[9],sum,sh,sl); printf("product of pos numbers : %ld\n",prod); getch(); clrscr(); return 0; }
void q4Top10Artigos() { HashTE *tmp = NULL; Top10Entry top10[10] = {}; initTop10(&top10); int i = 0, len = 0, posmin = 0, min = 0; for (i = 0; i < CAP; i++) { tmp = ht[i]; while (tmp) { len = lenCoAutores(tmp); insereTop10(&top10,len,tmp->nome,posmin, min); min = recalcMin(&top10, &posmin,10); tmp = tmp->seg; } } mySort(&top10); reverseTOP10(&top10); printf("-----TOP10-----\n"); for (i = 0; i < 10; i++) { printf("%d > %s %d\n", i+1, top10[i].nome, top10[i].nCoautores-1); // Há uma diferença de um coautor em todas as entradas por isso subtrai uma unidade. } }
void* findMaxSizeOfDuplicateSet(void *buf, size_t size, size_t total, int (*compare)(void const *a, void const *b)) { char *temp, *result; int counter = 0, i, maxCount = -1; if(total == 0 || size < 0 || buf == NULL) return NULL; // Cannot find the item element if((temp = myMalloc(size, total)) == NULL) { return NULL; } if((result = myMalloc(size, total)) == NULL) { return NULL; } mySort(buf, size, total, compare); memcpy(temp, buf, size); for(i = 0; i < total; i++) { if(compare(buf + i * size, temp) == 0) { counter++; } else { memcpy(temp, buf + i * size, size); counter = 1; } if(counter > maxCount) { maxCount = counter; memcpy(result, buf + i * size, size); } } free(temp); return result; }
int* findMaxDuplicateSet(void *buf, size_t size, size_t total, int *counter, void const *maxNumber, int (*compare)(void const *a, void const *b)) { int* result; int i; *counter = 0; if(total == 0 || size < 0 || buf == NULL) return NULL; // Cannot find the item element if((result = myMalloc(size, total)) == NULL) return NULL; mySort(buf, size, total, compare); for(i = 0; i < total; i++) { if(compare(buf + i * size, maxNumber) == 0) { result[(*counter)++] = i; } } return result; }
LetRecNode::LetRecNode(Compiler &compiler, const iter_t &node, bool isProgram) : Node(compiler, Node_ExprLetRec), _isProgram(isProgram) { unsigned j; unsigned jmax = node->children.size(); /* If this an usual letrec, not the program, then don't parse the last child element as an "in" expression. */ if (!isProgram) jmax -= 1; _expr = 0; // Parse RDecls map<string, RDecl*> vars; for (j = 0; j < jmax; j++) { RDecl *rd = new RDecl(compiler, node->children.begin() + j); if (vars.insert(make_pair(rd->alias, rd)).second == false) { throw logic_error("Multiple declarations of \"" + rd->alias + "\"."); } if (isProgram && compiler.testFlag(Compiler::OptimizeMain) && rd->alias == "main") { _expr = rd->expr; } else { _decls.push_back(rd); } } vars.clear(); // We're being very memory efficient here. Embedded here we come! if (isProgram) { if (!compiler.testFlag(Compiler::OptimizeMain)) { _expr = new IdentNode(compiler, "main"); } } else { _expr = Node::nodeFactory(compiler, node->children.begin() + j); } assert(_expr != 0); // Optimize out unused declarations if (!_decls.empty() && compiler.testFlag(Compiler::OptimizeUnused)) { DEBUGMSG("Optimizing unused variables:"); std::vector<RDecl*> decls(_decls); _decls.clear(); unsigned n = decls.size(); BoolMatrix b(n + 1, n + 1, false); for (unsigned c = 0; c < n; c++) { for (unsigned r = 0; r < n; r++) { if (decls.at(r)->expr->usesVariable(decls.at(c)->alias)) { b.data[r][c] = true; } } if (_expr->usesVariable(decls.at(c)->alias)) { b.data[n][c] = true; } } b.transformToTransitiveClosure(); #ifdef DEBUG unsigned unused = 0; #endif for (unsigned i = 0; i < n; i++) { if (b.data[n][i]) { _decls.push_back(decls.at(i)); } else { DEBUGMSG("Found unused variable \"" + decls.at(i)->alias + "\" in letrec."); #ifdef DEBUG unused++; #endif } } DEBUGMSG("Found " + intToString(unused) + "."); } // Reorder cyclic definitions if (_decls.size() > 1 && compiler.testFlag(Compiler::OptimizeLetRecDecls)) { BoolMatrix b(_decls.size(), _decls.size(), true); for (unsigned c = 0; c < _decls.size(); c++) { for (unsigned r = 0; r < _decls.size(); r++) { if (c == r) { b.data[r][r] = false; // Set identity values } else if (_decls.at(r)->expr->usesVariable(_decls.at(c)->alias)) { b.data[r][c] = false; } } } unsigned n = _decls.size(); vector<RDecl*> d(_decls); _decls.clear(); unsigned *ds = new unsigned[n]; for (unsigned i = 0; i < n; i++) ds[i] = i; MySort mySort(&b); stable_sort(ds, ds + n, mySort); for (unsigned i = 0; i < n; i++) _decls.push_back(d.at(ds[i])); delete ds; } }
int main(int argc, char * argv[]){ int a[5] = {234,456,23,78,12}; mySort(a,5); return 0; }
void beta::simulation_fast (parameters param) { // Initializing the data structures vector < vector < miniPkt > >frontConnect; vector < list < miniPkt > >dds; //allocation memory for the data structures for (int i = 0; i < param.neuronNum; i++) { vector < miniPkt > temp; list < miniPkt > temp1; frontConnect.push_back (temp); dds.push_back (temp1); } // getting the connections in the forward direction for (int odr = 0; odr < param.order - 1; odr++) { for (int i = 0; i < betas[odr].size (); i++) { for (int j = 0; j < betas[odr][i].size (); j++) { if (betas[odr][i][j].isConnection == true) { for (int k = 0; k < betas[odr][i][j].parents.size (); k++) { int parent = betas[odr][i][j].parents[k]; int delay = betas[odr][i][j].delays[k]; bool flag = true; int pos; for (int chk = 0; chk < frontConnect[parent - 1].size (); chk++) { if (frontConnect[parent - 1][chk].event == i) { pos = chk; flag = false; break; } } miniPkt temp; temp.event = i; temp.time = delay; if (flag == true) frontConnect[parent - 1].push_back (temp); else frontConnect[parent - 1][pos] = temp; } } } } } // FOR DEBUGGING #if 0 for (int i = 0; i < frontConnect.size (); i++) { displayMiniPkt (i, frontConnect[i]); } #endif //SIMULATION BEGINS fstream out; out.open (param.outfile.c_str (), ios::out); int num = param.neuronNum; int nUpdates = int (param.teeSim / param.teeUpdate); readfile stimFile (param.stimulusFile); for (int i = 0; i < nUpdates; i++) { vector < miniPkt > events; //cout << "time: " << i*param.teeUpdate << endl; for (int j = 0; j < num; j++) { //displayMiniPkt(j,dds[j]); double voltage = param.theta; list < miniPkt >::iterator nextIter; for (int odr = 1; odr < param.order - 1; odr++) { for (int pkts = 0; pkts < betas[odr][j].size (); pkts++) { bool addVoltage = true, parentThere; for (int k = 0; addVoltage == true && k < betas[odr][j][pkts].parents.size (); k++) { int parent = betas[odr][j][pkts].parents[k]; parentThere = false; for (list < miniPkt >::iterator listIter = dds[j].begin (); listIter != dds[j].end (); listIter++) { if (i * param.teeUpdate == (*listIter).time && (*listIter).event == parent - 1) { parentThere = true; break; } } addVoltage = addVoltage * parentThere; } if (addVoltage == true) voltage = voltage + betas[odr][j][pkts].beta; } } for (list < miniPkt >::iterator listIter = dds[j].begin (); listIter != dds[j].end (); listIter = nextIter) { nextIter = ++listIter; --listIter; if (i * param.teeUpdate == (*listIter).time) { voltage = voltage + betas[0][j][(*listIter).event].beta; dds[j].erase (listIter); } } double spikeTime; if (param.dist_flag == 0) { // getting a spiking time - with exponential distribution spikeTime = getExpSpikeTime (param.lambdaM, voltage); } else if (param.dist_flag == 1) { spikeTime = getGamma2SpikeTime (param.lambdaM, voltage); } if (spikeTime < param.teeUpdate) { miniPkt spkie; // check point : modifying the below line to reduce time resolution to param.teeUpdate // spkie.time = i*param.teeUpdate+spikeTime; spkie.time = i * param.teeUpdate; spkie.event = j + 1; events.push_back (spkie); //updating the dds of the neurons that are affected by firing of 'j' for (int w = 0; w < frontConnect[j].size (); w++) { int nextevent = frontConnect[j][w].event; double nextdelay = frontConnect[j][w].time; miniPkt temp; temp.time = (i + nextdelay) * param.teeUpdate; temp.event = j; dds[nextevent].push_back (temp); } } } // Including External Spikes into the data stream :) int spike; while ((spike = stimFile.getnextevent ()) != -1) { double spikeTime = stimFile.getTime (); if (spikeTime < (i + 1) * param.teeUpdate) { miniPkt tempevent; tempevent.time = spikeTime; tempevent.event = spike; //pushing into the data stream events.push_back (tempevent); //updating dds for (int w = 0; w < frontConnect[spike - 1].size (); w++) { int nextevent = frontConnect[spike - 1][w].event; double nextdelay = frontConnect[spike - 1][w].time; miniPkt temp; temp.time = (i + nextdelay) * param.teeUpdate; temp.event = spike - 1; dds[nextevent].push_back (temp); } } else { stimFile.pushBackOne (); break; } } //Sorting based on time mySort (events); for (int x = 0; x < events.size (); x++) { out << events[x].event << "," << events[x].time << endl; } } }