static TLDNode *balance(TLDNode *node) { int nodeDiff; nodeDiff=checkDiff(node); if (nodeDiff>1){ int checkLeft=checkDiff(node->left); if (checkLeft>0){ node=LL(node); }else{ node=LR(node); } }else if(nodeDiff<-1){ int checkRight=checkDiff(node->right); if (checkRight>0){ node=RL(node); }else{ node=RR(node); } }; return node; }
void Events::execute() { evolve(); newChoose:; double chooseEvent = _random() * rates.total; if (chooseEvent < rates.totalAds) { int index = static_cast<int> (floor(chooseEvent / rates.ads)); adsorption(index, atomType::metal); } else if (chooseEvent < rates.totalAds + rates.totalDes) { chooseEvent -= rates.totalAds; double cumulateRates = 0; unsigned ei = 0, ej = 0; while (cumulateRates + rates.sumsofDes[ei] < chooseEvent) { if (ei >= c::nDesTypes) { goto newChoose; } cumulateRates += rates.sumsofDes[ei++]; } ej = static_cast<int> (floor((chooseEvent - cumulateRates) / rates.des[ei])); if (ej >= eventLists._desEvents[ei].size()) { goto newChoose; }/* if (ei % c::nNeighCount == 0) _nFreeDes++; _nDesorbNeigh[ei % c::nNeighCount]++;*/ desorption(eventLists._desEvents[ei][ej]); } else { chooseEvent -= rates.totalAds + rates.totalDes; double cumulateRates = 0; unsigned ei = 0, ej = 0; while (cumulateRates + rates.sumsofDiff[ei] < chooseEvent) { if (ei >= c::nDiffTypes) { goto newChoose; } cumulateRates += rates.sumsofDiff[ei++]; } ej = static_cast<int> (floor((chooseEvent - cumulateRates) / rates.diff[ei])); if (ej >= eventLists._diffEvents[ei].size()) { goto newChoose; } checkDiff(ei, eventLists._diffEvents[ei][ej]); diffusion(eventLists._diffEvents[ei][ej]); } _nEvents++; }
PyObject* check(PyObject *self, PyObject *args) { int user_fd, right_fd, rst; if (!PyArg_ParseTuple(args, "ii", &right_fd, &user_fd)) RAISE0("run parseTuple failure"); if(checkDiff(right_fd, user_fd, &rst) == -1) return NULL; return Py_BuildValue("i", rst); }
void check(const FunctionCallbackInfo<Value>& args) { Isolate* isolate = args.GetIsolate(); if (args.Length() < 2) { isolate->ThrowException(Exception::TypeError( String::NewFromUtf8(isolate, "Wrong arugments") )); return; } int sampleIn; int userIn; int result; sampleIn = args[0]->Int32Value(); userIn = args[1]->Int32Value(); checkDiff(sampleIn, userIn, &result); args.GetReturnValue().Set(Number::New(isolate, result)); }
SourceView::SourceView(QWidget *parent,QFont & efont,bool line, QList<QColor> edcolors, QList<QColor> hicolors ) : QWidget(parent) { splitter=new MiniSplitter(this); splitter->setOrientation(Qt::Vertical); QFrame *framebis=new QFrame(splitter); framebis->setLineWidth(0); framebis->setFrameShape(QFrame::NoFrame); framebis->setFrameShadow(QFrame::Plain); framebis->setFrameStyle(QFrame::NoFrame); QVBoxLayout* mainlay = new QVBoxLayout(framebis ); mainlay->setSpacing(0); mainlay->setMargin(0); centralToolBar=new QToolBar("ToolBar",framebis); centralToolBar->setFloatable(false); centralToolBar->setOrientation(Qt::Horizontal); centralToolBar->setMovable(false); centralToolBar->setIconSize(QSize(16,16 )); centralToolBar->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum); mainlay->addWidget(centralToolBar); QAction *Act = new QAction(getIcon(":/images/fileopen16.png"), tr("Open"), this); connect(Act, SIGNAL(triggered()), this, SLOT(fileOpen())); centralToolBar->addAction(Act); centralToolBar->addSeparator(); titleLabel=new QLabel("(read only)",centralToolBar); centralToolBar->addWidget(titleLabel); centralToolBar->addSeparator(); Act = new QAction(getIcon(":/images/diff.png"), tr("Check differences"), this); connect(Act, SIGNAL(triggered()), this, SLOT(checkDiff())); centralToolBar->addAction(Act); QFrame *frame=new QFrame(framebis); frame->setLineWidth(0); frame->setFrameShape(QFrame::NoFrame); frame->setFrameShadow(QFrame::Plain); frame->setFrameStyle(QFrame::NoFrame); mainlay->addWidget(frame); lastdocument=""; editor=new LightLatexEditor(frame,efont,edcolors,hicolors,""); connect(editor, SIGNAL(requestFind()), this, SLOT(showFind())); connect(editor, SIGNAL(requestGotoLine()), this, SLOT(showGoto())); m_lineNumberWidget = new LightLineNumberWidget( editor, frame); m_lineNumberWidget->setFont(efont); QFontMetrics fm( efont ); m_lineNumberWidget->setFixedWidth( fm.width( "00000" ) + 22 ); QHBoxLayout* lay = new QHBoxLayout( frame ); lay->setSpacing(0); lay->setMargin(0); lay->addWidget( m_lineNumberWidget ); lay->addWidget( editor ); setFocusProxy( editor ); setLineNumberWidgetVisible(line); Stack=new QStackedWidget(this); Stack->setLineWidth(0); Stack->setFrameShape(QFrame::NoFrame); Stack->setFrameShadow(QFrame::Plain); findwidget=new LightFindWidget(Stack); Stack->addWidget(findwidget); findwidget->SetEditor(editor); connect(findwidget, SIGNAL( requestHide() ), Stack, SLOT( hide() ) ); connect(findwidget, SIGNAL( requestExtension() ), this, SLOT( showFind() ) ); gotolinewidget=new LightGotoLineWidget(Stack); Stack->addWidget(gotolinewidget); gotolinewidget->SetEditor(editor); connect(gotolinewidget, SIGNAL( requestHide() ), Stack, SLOT( hide() ) ); Stack->hide(); splitter->addWidget(framebis); splitter->addWidget(Stack); QVBoxLayout *mainlayout= new QVBoxLayout(this); mainlayout->setSpacing(0); mainlayout->setMargin(0); mainlayout->addWidget(splitter); }
/* The processing loop. Kinda superstep style, everyone copies, everyone averages and then everyone checks if they're done. Will quit when every thread says it has finished. */ void* threadLoop( void* inData) { LoopData* theData = (LoopData*) inData; int i, diff = 0; // Little bit of indirection to make access easier/simpler float** currArray = theData->inArray; float** nextArray = theData->outArray; int arrayX = theData->arrayX; int arrayY = theData->arrayY; float precision = theData->precision; int* finishedThreads = theData->finishedThreads; for( i = 0; i < arrayX; i++) { memcpy(nextArray[i], theData->inArray[i], arrayY * sizeof(float)); } while( 1 ) { //copy the next array into the working copy. for( i = 1; i < arrayX - 1; i++) { memcpy(currArray[i], nextArray[i], arrayY * sizeof(float)); } //Wait until everyones done that if(theData->barrier != NULL) { pthread_barrier_wait(theData->barrier); } averageFour(currArray, nextArray, arrayX, arrayY); diff = checkDiff(currArray, nextArray, arrayX, arrayY, precision); if (diff != 0) { if(theData->finLock != NULL) { pthread_mutex_lock(theData->finLock); } (*finishedThreads)++; if(theData->finLock != NULL) { pthread_mutex_unlock(theData->finLock); } } // Wait for everyone again if(theData->barrier != NULL) { pthread_barrier_wait(theData->barrier); } // If everyone is done we can go if ((*finishedThreads) == theData->numThreads) { break; } else //otherwise we have to try again { (*finishedThreads) = 0; // Didn't lock as we're setting to a constant and the only other // modification of the variable is behind a barrier in the loop. } } return 0; }
int main(int argc, char **argv) { // Initial values (should get from cmd line) int arraySize = 10; float precision = 10; int numThreads = 2; __VERBOSE = 0; int arrSeed = time(0); int testRight = 0; // Read options // -s is the size, -p is the precision and -t is number of threads. // -v turns on some debug spew int c; opterr = 0; while ((c = getopt (argc, argv, "s:p:t:vr:c")) != -1) { switch (c) { case 'p': if (sscanf(optarg, "%f", &precision) != 1) { fprintf (stderr, "Option -%c requires a float argument.\n", optopt); printUsage(); } break; case 'r': if (sscanf(optarg, "%i", &arrSeed) != 1) { fprintf (stderr, "Option -%c requires an integer argument.\n", optopt); printUsage(); } break; case 's': if (sscanf(optarg, "%i", &arraySize) != 1) { fprintf (stderr, "Option -%c requires an integer argument.\n", optopt); printUsage(); } break; case 't': if (sscanf(optarg, "%i", &numThreads) != 1) { fprintf (stderr, "Option -%c requires an integer argument.\n", optopt); printUsage(); } break; case 'v': __VERBOSE = 1; break; case 'c': testRight = 1; break; default: printUsage(); } } #ifdef PTHREAD_THREADS_MAX // Linux don't got this if (numThreads > PTHREAD_THREADS_MAX) { numThreads = PTHREAD_THREADS_MAX; } #endif if (numThreads && (arraySize / numThreads) < 2) { numThreads = arraySize / 2; } // Start timer struct timeval start_tv, end_tv; gettimeofday(&start_tv,NULL); printf("Starting to relax %d square array to precision %f.", arraySize, precision); printf("Using %d thread%s (other than main).\n", numThreads, numThreads == 1 ? "" : "s"); printf(". Seed: %d.\n", arrSeed); // Initializing and mallocing the arrays float** currArray = make2DFloatArray(arraySize, arraySize); float** nextArray = make2DFloatArray(arraySize, arraySize); initArray(currArray, arraySize, arrSeed); // Do the work relaxationThreaded(currArray, nextArray, arraySize, precision, numThreads); // Stop timer here. gettimeofday(&end_tv,NULL); int correct = 0; if(testRight) { // Create 2 more arrays, we'll do it again serially float** currArray2 = make2DFloatArray(arraySize, arraySize); float** nextArray2 = make2DFloatArray(arraySize, arraySize); initArray(currArray2, arraySize, arrSeed); if(__VERBOSE) { printf("Original:\n"); printSquareArray(currArray, arraySize); } relaxationThreaded(currArray2, nextArray2, arraySize, precision, 0); correct = checkDiff(nextArray, nextArray2, arraySize, arraySize, precision); if(__VERBOSE) { printf("\nThreaded:\n"); printSquareArray(nextArray, arraySize); printf("\nSerial:\n"); printSquareArray(nextArray2, arraySize); } // Cleanup free2DFloatArray(currArray2, arraySize); free2DFloatArray(nextArray2, arraySize); } // Cleanup free2DFloatArray(currArray, arraySize); free2DFloatArray(nextArray, arraySize); long long durr_us = (end_tv.tv_sec * (long long)1000000 + end_tv.tv_usec) - (start_tv.tv_sec * (long long)1000000 + start_tv.tv_usec); printf("Relaxed %d square matrix in %llu microsceonds\n", arraySize, durr_us); if(testRight) { printf("Threaded relaxation result %s the serial result.\n", correct ? "matched" : "didnt match"); } // Windows command to stop console applications closing immediately. system("pause"); return 0; }
void RayTracer::tracePixelAdapt(int i, int j) { vec3f col; if (!scene) return; double x = double(i) / double(buffer_width); double y = double(j) / double(buffer_height); double pixWidth = 1.0 / double (buffer_width); double pixHeight = 1.0 / double (buffer_height); double xMin = x - pixWidth/2.0; //In case negative values if (xMin < RAY_EPSILON) { xMin = RAY_EPSILON; } double xMax = x + pixWidth / 2.0; double yMin = y - pixHeight / 2.0; if (yMin < RAY_EPSILON) { yMin = RAY_EPSILON; } double yMax = y + pixHeight / 2.0; double xVals[2] = { xMin, xMax }; double yVals[2] = { yMin, yMax }; unsigned char corners[2][2][3]; for (int w = 0; w < 2; w++) { for (int h = 0; h < 2; h++) { int xPos = i + w; int yPos = j + h; if (bufferFilled[yPos*(buffer_width + 1) + xPos]) { unsigned char* pixel = cornerBuffer + (yPos * (buffer_width + 1) + xPos) * 3; corners[w][h][0] = pixel[0]; corners[w][h][1] = pixel[1]; corners[w][h][2] = pixel[2]; } else { col = trace(scene, xVals[w], yVals[h]); unsigned char *pixel = cornerBuffer + (xPos + yPos * buffer_width+1) * 3; pixel[0] = (int)(255.0 * col[0]); pixel[1] = (int)(255.0 * col[1]); pixel[2] = (int)(255.0 * col[2]); corners[w][h][0] = pixel[0]; corners[w][h][1] = pixel[1]; corners[w][h][2] = pixel[2]; bufferFilled[yPos*(buffer_width + 1) + xPos] = true; } } } unsigned char avg[3]; unsigned char *pixel = buffer + (i + j * buffer_width) * 3; if (checkDiff(corners, 2, avg)) { pixel[0] = avg[0]; pixel[1] = avg[1]; pixel[2] = avg[2]; } else { vec3f subCol[4]; vec3f colSum = vec3f(0,0,0); double subx[4]; double suby[4]; double halfWidth = pixWidth / 2.0; double halfHeight = pixHeight / 2.0; subx[0] = xMin; suby[0] = yMin; subx[1] = xMin + halfWidth; suby[1] = yMin; subx[2] = xMin; suby[2] = yMin + halfHeight; subx[3] = xMin + halfWidth; suby[3] = yMin + halfHeight; for (int i = 0; i < 4; i++) { colSum += qSubPix(subx[i], suby[i], halfWidth, halfHeight, 1); } colSum /= 4.0; pixel[0] = (int)(255.0 * colSum[0]); pixel[1] = (int)(255.0 * colSum[1]); pixel[2] = (int)(255.0 * colSum[2]); } }