void process2(trip a[MAXN], int*ac, char s[MAXN], int sc, int*pos){ if (s[*pos ] == '['){ while (s[*pos] != ']') { (*pos)++; int num = 0; while ((s[*pos] != ',') && (s[*pos] != ']')) { num = num * 10 + (int)(s[*pos] - '0'); (*pos)++; } a[*ac].first = num; a[*ac].second.first = -1; a[*ac].second.second = -1; (*ac)++; } (*pos)++; } else if (s[*pos ] == 'c'){ (*pos) += 7; process2(a, ac, s, sc, pos); (*pos)++; process2(a, ac, s, sc, pos); (*pos)++; } else if (s[*pos+1] == 'o'){ (*pos) += 7; process2(a, ac, s, sc, pos); (*pos)++; } else { (*pos) += 8; process2(a, ac, s, sc, pos); (*pos)++; } }
int main() { const char buf[] = "i am children 2"; nokia::AffinityProcess process1(Process1); nokia::AffinityProcess process2(Process2, static_cast<void*>(const_cast<char*>(buf))); nokia::AffinityProcess process3(Process2, static_cast<void*>(const_cast<char*>("22"))); nokia::AffinityProcess process4(Process2, static_cast<void*>(const_cast<char*>("33"))); nokia::AffinityProcess process5(Process2, static_cast<void*>(const_cast<char*>("44"))); nokia::AffinityProcess process6(Process2, static_cast<void*>(const_cast<char*>("55"))); nokia::AffinityProcess process7(Process2, static_cast<void*>(const_cast<char*>("66"))); nokia::AffinityProcess process8(Process2, static_cast<void*>(const_cast<char*>("77"))); nokia::AffinityProcess process9(Process2, static_cast<void*>(const_cast<char*>("88"))); nokia::AffinityProcess process10(Process2, static_cast<void*>(const_cast<char*>("99"))); process1.Wait(); process2.Wait(); process3.Wait(); process4.Wait(); process5.Wait(); process6.Wait(); process7.Wait(); process8.Wait(); process9.Wait(); process10.Wait(); return 0; }
void process (trip a[MAXN], int*ac, char s[MAXN], int sc, int*pos){ if (s[*pos ] == '['){ while (s[*pos] != ']'){ (*pos)++; int num = 0; while ((s[*pos] != ',') && (s[*pos] != ']')) { num = num * 10 + (int)(s[*pos] - '0'); (*pos)++; } a[*ac].first = num; a[*ac].second.first = -1; a[*ac].second.second = -1; (*ac)++; } (*pos)++; } else if (s[*pos ] == 'c'){ (*pos) += 7; process(a, ac, s, sc, pos); (*pos)++; process(a, ac, s, sc, pos); (*pos)++; } else if (s[*pos+1] == 'o'){ (*pos) += 7; int cur = *ac; process2(a, ac, s, sc, pos); qsort(a+cur, (*ac)-cur, sizeof(trip), cmpT); (*pos)++; } else { (*pos) += 8; int cur = *ac; process2(a, ac, s, sc, pos); qsort(a+cur, (*ac)-cur, sizeof(trip), cmpT); if(cmpT(&a[cur], &a[*ac-1])!=0){ for (int i = cur; i < *ac; i++) { a[i].second.first = cur; a[i].second.second = *ac; } } (*pos)++; } }
int main() { int n,sum1,sum2; for(n = 1;n<20000;n++) { sum1 = process1(n); sum2 = process2(n); if(sum1 != sum2) printf("%d %d %d\n",n,sum1,sum2); } return 0; }
void process( array * base ) { if ( base->k > MAXK ) return; process1( base ); if ( base->t < MAXT ) { process2( base ); } process3( base ); }
//This method creates process to run process2 by forking the current process. void createProcess2(){ pid_t childPID; //Forks another process, for process2 which replaces ** with ^ switch(childPID = fork()){ //checks if forked successfully case -1: perror("fork failed"); exit(EXIT_FAILURE); //closes the appropriate pipes and calls process2 case 0: close(pipe1[0]); close(pipe1[1]); close(pipe2[1]); close(pipe3[0]); process2(pipe2[0],pipe3[1]); break; //Parent continues to fork for the last process, by calling a function to create //process for writeOut and it then waits for child process. default: createWriteOut(); wait(); } }
void ViBenchMarker3::process1(bool generate) { QObject::disconnect(mCurrentObject.data(), SIGNAL(decoded()), this, SLOT(process1())); if(generate) { ViNoiseCreator creator; creator.createNoise(mCurrentObject->buffer(ViAudio::Target), mCurrentObject->buffer(ViAudio::Corrupted), mCurrentObject->buffer(ViAudio::CustomMask), mCurrentObject->buffer(ViAudio::Custom)); } mCurrentObject->clearBuffer(ViAudio::Target); mCurrentObject->clearBuffer(ViAudio::Noise); mCurrentObject->clearBuffer(ViAudio::NoiseMask); /*if(mParamsStart.size() == 1) mDetector->setParameters(mParamsCurrent[0]); else if(mParamsStart.size() == 2) mDetector->setParameters(mParamsCurrent[0], mParamsCurrent[1]); else if(mParamsStart.size() == 3) mDetector->setParameters(mParamsCurrent[0], mParamsCurrent[1], mParamsCurrent[2]); else if(mParamsStart.size() == 4) mDetector->setParameters(mParamsCurrent[0], mParamsCurrent[1], mParamsCurrent[2], mParamsCurrent[3]); //else { cout << "Invalid parameter count of "<<mParamsStart.size()<<". Min: 1, Max: 4" << endl; quit(); }*/ QObject::connect(mCurrentObject.data(), SIGNAL(noiseGenerated()), this, SLOT(process2())); mTime.restart(); mCurrentObject->generateNoiseMask(mDetector); }
void FeatPyramid::featpyramid (const IplImage *im, const Model *model, int padX, int padY) { float sbin, interval; float sc; int imsize[2]; float maxScale; IplImage *imAux = NULL; int pad[3]; if (padX == -1 && padY == -1) { padX = getPaddingX(model); padY = getPaddingY(model); } sbin = (float)model->getSbin(); interval = (float) model->getInterval()+1.0; sc = pow (2, 1/(interval)); imsize[0] = im->height; imsize[1] = im->width; maxScale = 1 + floor ( log ( min (imsize[0], imsize[1]) / (5*sbin) ) / log(sc) ); // It is the number of elements that will contain pyramid->features // and pyramid->scales. At less must be 2*interval if ( (maxScale + interval) < (2*interval) ) setDim (int(2*interval)); else setDim (int(maxScale + interval)); assert (getDim() > 0); // _feat = new CvMatND* [getDim()]; // Suspicious _feat.reserve(getDim()); for (int i = 0; i < getDim(); i++) // Pre-allocate memory _feat.push_back(cv::Mat()); // assert (_feat != NULL); assert(!_feat.empty()); _scales = new float [getDim()]; // Suspicious assert (_scales != NULL); // Field imsize is setted assert (imsize[0] > 0); assert (imsize[1] > 0); setImSize (imsize); //cout << "Antes de bucle featpyramid" << endl; for (int i = 0; i < interval; i++) { // Image is resized imAux = resize (im, (1/pow(sc, i))); // "First" 2x interval //setFeat(process(imAux, sbin/2), i); setFeat(process2(imAux, sbin/2), i); setScales(2/pow(sc, i), i); // "Second" 2x interval //setFeat (process (imAux, sbin), (int)(i+interval)); setFeat (process2 (imAux, sbin), (int)(i+interval)); setScales (1/pow(sc, i), (int)(i+interval)); // Remaining intervals IplImage *imAux2; // mjmarin added for (int j = (int)(i+interval); j < (int)maxScale; j = j+(int)interval) { // mjmarin: memory leak fixed //imAux = resize (imAux, 0.5); // Old sentence imAux2 = resize (imAux, 0.5); cvReleaseImage(&imAux); imAux = imAux2; //setFeat (process (imAux, sbin), (int)(j+interval)); setFeat (process2 (imAux, sbin), (int)(j+interval)); setScales ((float)(0.5 * getScales()[j]), (int)(j+interval)); } // mjmarin: more release needed for imAux cvReleaseImage(&imAux); } // Second loop for (int i = 0; i < getDim(); i++ ) { // Add 1 to padding because feature generation deletes a 1-cell // Wide border around the feature map pad[0] = padY + 1; pad[1] = padX + 1; pad[2] = 0; //CvMatND* tmpfeat = getFeat()[i]; cv::Mat tmpfeat = getFeat()[i]; CvMatND tmpND = tmpfeat; //CvMatND* tmppad = padArray (tmpfeat, pad, 0); CvMatND* tmppad = padArray (&tmpND, pad, 0); setFeat (tmppad, i); //cvReleaseMatND(&tmpfeat); // mjmarin: commented out since it should be auto released with use of cv::Mat // Write boundary occlusion feature cv::Mat fMat = getFeat()[i]; for (int j = 0; j <= padY; j++) //for (int k = 0; k < getFeat()[i]->dim[1].size; k++) for (int k = 0; k < fMat.size.p[1]; k++) //cvSetReal3D (getFeat()[i], j, k, 31, 1); fMat.at<double>(j, k, 31) = 1; //for (int j = getFeat()[i]->dim[0].size - padY -1; j < getFeat()[i]->dim[0].size; j++) for (int j = fMat.size.p[0] - padY -1; j < fMat.size.p[0]; j++) //for (int k = 0; k < getFeat()[i]->dim[1].size; k++) for (int k = 0; k < fMat.size.p[1]; k++) //cvSetReal3D (getFeat()[i], j, k, 31, 1); fMat.at<double>(j, k, 31) = 1; //for (int j = 0; j < getFeat()[i]->dim[0].size; j++) for (int j = 0; j < fMat.size.p[0]; j++) for (int k = 0; k <= padX; k++) //cvSetReal3D (getFeat()[i], j, k, 31, 1); fMat.at<double>(j, k, 31) = 1; //for (int j = 0; j < getFeat()[i]->dim[0].size; j++) for (int j = 0; j < fMat.size.p[0]; j++) //for (int k = getFeat()[i]->dim[1].size - padX - 1; k < getFeat()[i]->dim[1].size; k++) for (int k = fMat.size.p[1] - padX - 1; k < fMat.size.p[1]; k++) //cvSetReal3D (getFeat()[i], j, k, 31, 1); fMat.at<double>(j, k, 31) = 1; } setPadX (padX); setPadY (padY); }
/* ----------------------------------------------------------------------------- * Define test script here. */ void TestCase::runTest( void ) { /* ------------------------------ */ UT_START_STEP( 1 ); unsigned type = 0; Process process( type ); UT_COMMENT( "Checking default values after object instantiation...\n" ); UT_CHECK_OUTPUT( type == process.getType() ); UT_CHECK_OUTPUT( false == process.isDead() ); UT_CHECK_OUTPUT( false == process.isPaused() ); UT_CHECK_OUTPUT( false == process.isAttached() ); UT_CHECK_OUTPUT( false == process.initRequired() ); UT_CHECK_OUTPUT( true == process.isActive() ); UT_CHECK_OUTPUT( NULL == process.getNext() ); UT_END_STEP; /* ------------------------------ */ UT_START_STEP( 2 ); unsigned type = 0; Process process( type ); UT_COMMENT( "Checking default setters and getters...\n" ); UT_CHECK_OUTPUT( 0 == process.getType() ); process.setType( 1 ); UT_CHECK_OUTPUT( 1 == process.getType() ); process.setActive( false ); UT_CHECK_OUTPUT( false == process.isActive() ); process.setActive( true ); UT_CHECK_OUTPUT( true == process.isActive() ); process.setAttached( true ); UT_CHECK_OUTPUT( true == process.isAttached() ); process.setAttached( false ); UT_CHECK_OUTPUT( false == process.isAttached() ); process.togglePause(); UT_CHECK_OUTPUT( true == process.isPaused() ); process.togglePause(); UT_CHECK_OUTPUT( false == process.isPaused() ); Process process2( 0 ); process.setNext( &process2 ); UT_CHECK_OUTPUT( &process2 == process.getNext() ); process.setNext( NULL ); UT_CHECK_OUTPUT( NULL == process.getNext() ); process.kill(); UT_CHECK_OUTPUT( true == process.isDead() ); UT_END_STEP; /* ------------------------------ */ UT_START_STEP( 3 ); UT_COMMENT( "Checking default Process::onUpdate() method...\n" ); static bool on_initialize_called = false; class FooProcess : public Process { public: FooProcess( unsigned type ) : Process( type ) { m_InitRequired = true; } // Overwrite onInitialize protected: virtual void onInitialize( void ) { on_initialize_called = true; } }; Process process( 0 ); UT_CHECK_OUTPUT( false == process.initRequired() ); process.onUpdate( 0 ); UT_CHECK_OUTPUT( false == on_initialize_called ); FooProcess fooprocess( 0 ); UT_CHECK_OUTPUT( true == fooprocess.initRequired() ); fooprocess.onUpdate( 0 ); UT_CHECK_OUTPUT( true == on_initialize_called ); UT_CHECK_OUTPUT( false == fooprocess.initRequired() ); UT_END_STEP; /* ------------------------------ */ return; }
void ViBenchMarker3::process2() { int time = mTime.elapsed(); QObject::disconnect(mCurrentObject.data(), SIGNAL(noiseGenerated()), this, SLOT(process2())); /*QObject::connect(mCurrentObject.data(), SIGNAL(encoded()), this, SLOT(quit())); mCurrentObject->encode(ViAudio::Noise); return;*/ qreal maxMAT = 0; qint64 maxTP = 0, maxTN = 0, maxFP = 0, maxFN = 0; qint64 i, lengthIndex, offset1 = 0, offset2 = 0; int noChange = 0; ViAudioReadData corrupted(mCurrentObject->buffer(ViAudio::Noise)); ViAudioReadData realMask(mCurrentObject->buffer(ViAudio::CustomMask)); ViAudioReadData length(mCurrentObject->buffer(ViAudio::Custom)); corrupted.setSampleCount(WINDOW_SIZE); realMask.setSampleCount(WINDOW_SIZE); length.setSampleCount(WINDOW_SIZE); ViSampleChunk *nData1 = new ViSampleChunk(corrupted.bufferSamples() / 2); ViSampleChunk *nData2 = new ViSampleChunk(corrupted.bufferSamples() / 2); ViSampleChunk *nMask1 = new ViSampleChunk(corrupted.bufferSamples() / 2); ViSampleChunk *nMask2 = new ViSampleChunk(corrupted.bufferSamples() / 2); ViSampleChunk *nRealMask1 = new ViSampleChunk(realMask.bufferSamples() / 2); ViSampleChunk *nRealMask2 = new ViSampleChunk(realMask.bufferSamples() / 2); ViSampleChunk *nLength1 = new ViSampleChunk(corrupted.bufferSamples() / 2); ViSampleChunk *nLength2 = new ViSampleChunk(corrupted.bufferSamples() / 2); while(corrupted.hasData() && realMask.hasData()) { corrupted.read(); ViSampleChunk &corrupted1 = corrupted.splitSamples(0); ViSampleChunk &corrupted2 = corrupted.splitSamples(1); realMask.read(); ViSampleChunk &realMask1 = realMask.splitSamples(0); ViSampleChunk &realMask2 = realMask.splitSamples(1); length.read(); ViSampleChunk &length1 = length.splitSamples(0); ViSampleChunk &length2 = length.splitSamples(1); for(i = 0; i < corrupted1.size(); ++i) { (*nData1)[i + offset1] = corrupted1[i]; (*nRealMask1)[i + offset1] = realMask1[i]; (*nLength1)[i + offset1] = length1[i]; } offset1 += corrupted1.size(); for(i = 0; i < corrupted2.size(); ++i) { (*nData2)[i + offset2] = corrupted2[i]; (*nRealMask2)[i + offset2] = realMask2[i]; (*nLength2)[i + offset2] = length2[i]; } offset2 += corrupted2.size(); } mCurrentObject->clearBuffer(ViAudio::Target); mCurrentObject->clearBuffer(ViAudio::Noise); mCurrentObject->clearBuffer(ViAudio::NoiseMask); ViNoise noise1(nData1, nMask1, mCurrentThreshold); ViNoise noise2(nData2, nMask2, mCurrentThreshold); QVector<qreal> lengthTP(ViNoiseCreator::noiseSizeCount()); QVector<qreal> lengthFN(ViNoiseCreator::noiseSizeCount()); lengthTP.fill(0); lengthFN.fill(0); QVector<qreal> maxLengthTP, maxLengthFN; for(mCurrentThreshold = MASK_START; mCurrentThreshold <= MASK_END; mCurrentThreshold += MASK_INTERVAL) { noise1.setThreshold(mCurrentThreshold); noise1.generateMask(ViNoise::NOISE_TYPE); noise2.setThreshold(mCurrentThreshold); noise2.generateMask(ViNoise::NOISE_TYPE); qint64 truePositives = 0, falsePositives = 0, trueNegatives = 0, falseNegatives = 0; for(i = 0; i < nRealMask1->size(); ++i) { if((*nRealMask1)[i] == 1) { lengthIndex = ViNoiseCreator::fromSizeMask((*nLength1)[i]) - 1; if((*nMask1)[i] == 1) { ++truePositives; lengthTP[lengthIndex] += 1; } else { ++falseNegatives; lengthFN[lengthIndex] += 1; } } else if((*nRealMask1)[i] == 0) { if((*nMask1)[i] == 1) ++falsePositives; else ++trueNegatives; } } for(i = 0; i < nRealMask2->size(); ++i) { if((*nRealMask2)[i] == 1) { lengthIndex = ViNoiseCreator::fromSizeMask((*nLength2)[i]) - 1; if((*nMask2)[i] == 1) { ++truePositives; lengthTP[lengthIndex] += 1; } else { ++falseNegatives; lengthFN[lengthIndex] += 1; } } else if((*nRealMask2)[i] == 0) { if((*nMask2)[i] == 1) ++falsePositives; else ++trueNegatives; } } qreal math = matthews(truePositives, trueNegatives, falsePositives, falseNegatives); if(math > maxMAT) { maxMAT = math; maxTP = truePositives; maxTN = trueNegatives; maxFP = falsePositives; maxFN = falseNegatives; maxLengthTP = lengthTP; maxLengthFN = lengthFN; noChange = 0; } ++noChange; if(noChange > NO_CHANGE) break; } delete nRealMask1; delete nRealMask2; delete nLength1; delete nLength2; ++mDoneParamIterations; if(maxMAT > mBestMatthews) mBestMatthews = maxMAT; printFileData(time, maxTP, maxTN, maxFP, maxFN, maxLengthTP, maxLengthFN); printTerminal(time, maxTP, maxTN, maxFP, maxFN, mBestMatthews); if(nextParam()) process1(false); else nextFile(); }
static #endif void traverseLcpTree(Int64 *lcpTab, Int64 *sa, Sequence *seq, Int64 numOfSubjects, Int64 numOfQueries, Int64 *seqBorders , Int64 *leftBorders, Int64 *strandBorders , queryInterval ***listQueryIntervalsFwd // lists of query intervals, there are |Q| lists , queryInterval ***listQueryIntervalsRev // lists of query intervals, there are |Q| lists , Int64 maxDepth, Int64 *maxShulens , queryInterval ***fastSearch, Int64 *lastIndex, qNode ***root) { Interval *lastInterval, *interval; Int64 i, j, lb, rightEnd, lastIsNull; //Int64 numOfChildren; Stack *treeStack = NULL; Stack *reserveStack = NULL; // reserve stack for intervals Stack *reserveQIStack = NULL; // reserve stack for query intervals short *QS; /* array of subject and query indexes corresponding to each position in the SA; pos. values --> subjects, neg.values --> queries */ //queryLeaves - maximal number is the maximal number of leaves at each interval; queryLeaves[i][0]-query index, queryLeaves[i][1]-position in a query Int64 queryLeaves[MAXNUMLEAVES][2]; //queryLeaves[i][0]-query index, queryLeaves[i][1]-position in a query int maxCols = 2; int step = STEP; queryInterval *qi = NULL; qNode *qn = NULL; // unresolvedQLeaves - unresolved leaves from the interval's subtree; unresolvedQLeaves[i][0]-query index, unresolvedQLeaves[i][1]-position in a query Int64 *unresolvedQLeaves = NULL; Int64 maxUnresQLeaves = 100; unresolvedQLeaves = emalloc(maxUnresQLeaves * sizeof(Int64) * 2); // * 2 since each leaf is represented by ints query index and a position within a query /* allocate 2 lists of |Q| pointers; one list is the beginning and the other is end of the list */ if (BSEARCH) { *root = getBTQueryIntervals(numOfQueries); } else { *listQueryIntervalsFwd = getListQueryIntervals(numOfQueries); *listQueryIntervalsRev = getListQueryIntervals(numOfQueries); } /* initialize auxiliary arrays: subjects and queryLeaves */ QS = getQS(seqBorders, leftBorders, numOfSubjects, numOfQueries, step); //queryLeaves = getQueryLeaves(&numQueryLeaves, &maxNumLeaves); sa++; /* since data in sa and lcpTab start with position 1, and not 0 */ lcpTab++; rightEnd = seq->len-1; lcpTab[0] = 0; /* or -1 */ treeStack = createStack(); /* true stack */ lastIsNull = 1; lastInterval = NULL; interval = NULL; push(treeStack, getInterval(0, 0, rightEnd, NULL, numOfSubjects, NULL, maxDepth)); /* push root node to the stack */ /* auxiliary stack for (Interval *); used for saving used allocated locations; since stack operations pop/push are faster than malloc */ reserveStack = createStack(); /* auxiliary stack for (queryInterval *) */ reserveQIStack = createStack(); for (i = 1; i < seq->len; i++){ lb = i - 1; while(lcpTab[i] < ((Interval *)(treeStack->top))->lcp) { /* end of the previous interval, so the interval should be popped from the stack*/ /* if the current top is the child of the new node, then pop the top */ ((Interval *)(treeStack->top))->rb = i - 1; lastInterval = (Interval *)pop(treeStack); process2(lastInterval, *listQueryIntervalsFwd, *listQueryIntervalsRev, seqBorders, leftBorders, strandBorders, numOfSubjects, QS, step, &queryLeaves[0][0], maxCols, sa, &unresolvedQLeaves, &maxUnresQLeaves, reserveQIStack, maxShulens, fastSearch, lastIndex, *root); lb = lastInterval->lb; /* save child intervals of popped interval */ for(j = 0; j < lastInterval->numChildren; j ++) { lastInterval->children[j]->numChildren = 0; lastInterval->children[j]->parent = NULL; push(reserveStack, (void *)lastInterval->children[j]); } lastIsNull = 0; if (lcpTab[i] <= ((Interval *)treeStack->top)->lcp) { /* the new top is the parent of the ex top*/ lastInterval->parent = treeStack->top; addChild((Interval *)treeStack->top, lastInterval); lastIsNull = 1; } } /* end while */ if (lcpTab[i] > ((Interval *)treeStack->top)->lcp) { /* add interval to the stack */ if (isEmpty(reserveStack)) { //interval = getInterval(lcpTab[i], lb, rightEnd, NULL, numOfSubjects, treeStack->top, maxDepth);// treeStack->top or null interval = getInterval(lcpTab[i], lb, rightEnd, NULL, numOfSubjects, NULL, maxDepth); } else { /* use locations from the reserveStack */ interval = pop(reserveStack); // pop the last child of the lastInterval from the reservestack interval->lcp = lcpTab[i]; interval->lb = lb; interval->rb = rightEnd; interval->numChildren = 0; interval->parent = NULL; } if (!lastIsNull){ lastInterval->parent = interval; addChild(interval, lastInterval); lastIsNull = 1; } push(treeStack, interval); } } #if DEBUG printf("Empting stack...\n"); printf("Number of intervals allocated:%lld\n\n", (long long)numInterval); #endif while(!isEmpty(treeStack)) { interval = pop(treeStack); /* when the stack is not empty and the current interval has no parent, then his parent is on the top of the stack*/ if (!isEmpty(treeStack) && !interval->parent && interval->lcp > ((Interval *)(treeStack->top))->lcp) { interval->parent = treeStack->top; addChild((Interval *)treeStack->top, interval); } /* process: * 1) it labels an interval according to whether it has ST leaves from query (isQuery) or from subject (isSubject) or both (isQuery && isSubject). * 2) if(isQuery && isSubject) it determines the corresponding query shustring lengths (if any) */ process2(interval, *listQueryIntervalsFwd, *listQueryIntervalsRev, seqBorders, leftBorders, strandBorders, numOfSubjects, QS, step, &queryLeaves[0][0], maxCols, sa, &unresolvedQLeaves, &maxUnresQLeaves, reserveQIStack, maxShulens, fastSearch, lastIndex, *root); for (i = 0; i < interval->numChildren; i++) { freeInterval((void *)interval->children[i]); } interval->numChildren = 0; if (!interval->parent) { freeInterval((void *)interval); } } //freeInterval((void *)interval); /* free the root interval; it has to be done here, what is different from kr 2!! */ freeStack(treeStack, freeInterval); /* free memory allocated for the reserveStack */ while (!isEmpty(reserveStack)) { interval = pop(reserveStack); for (i = 0; i < interval->numChildren; i++) { freeInterval((void *)interval->children[i]); } //freeInterval((void *)interval); /* free the root interval */ if (!interval->parent) { freeInterval((void *)interval); } } /* free reserve stack */ freeStack(reserveStack, freeInterval); /* free reserve queryInterval stack */ if (BSEARCH) { while (!isEmpty(reserveQIStack)) { qn = pop(reserveQIStack); qn->left = qn->right = NULL; freeQNode(qn); } freeStack(reserveQIStack, freeQNode); } else { while (!isEmpty(reserveQIStack)) { qi = pop(reserveQIStack); qi->next = qi->prev = NULL; freeQueryInterval(qi); } freeStack(reserveQIStack, freeQueryInterval); } #if DEBUG printf("Finished.. Number of intervals allocated:%lld\n\n", (long long)numInterval); #endif free(QS); free(unresolvedQLeaves); //printf("maxUnresQLeaves = %d\n", maxUnresQLeaves); }