void MultilayerPerceptron::run() { vector<vector<double> > inputs = ts->getInputs(), targets = ts->getTargets(); StopCondition //BP parameters sc = (StopCondition)mlpbpts->getStopParameter(); double //SA parameters startCondition = 0, To = 0, minNoise = 0, maxNoise = 0, tempDecFactor = 0, Tmin = 0, //BP parameters learningRate = mlpbpts->getLearningRate(), MSEmin = mlpbpts->getMinMSE(), RMSEmin = mlpbpts->getMinRMSE(), CEmin = mlpbpts->getMinCE(); unsigned int //SA parameters nChanges = 0, //BP parameters epochs = mlpbpts->getMaxEpochs(); if(sa){ startCondition = mlpsats->getLocalMinimumCondition(); To = mlpsats->getTo(); minNoise = mlpsats->getMinNoise(); maxNoise = mlpsats->getMaxNoise(); tempDecFactor = mlpsats->getTempDecrementFactor(); Tmin = mlpsats->getMinTemperature(); nChanges = mlpsats->getChanges(); } size_t nPatterns, nNeurons, nBOutputs, nOutputs; vector<double> yObtained, deltaOut(outputWeights.size(), 0); // vector<vector<double> > deltaHidden(layerWeights.size()); deltaHidden.resize(layerWeights.size()); for(size_t i = 0; i < deltaHidden.size(); i++){ size_t sLayer = layerWeights[i].size(); deltaHidden[i].resize(sLayer, 0); } nPatterns = inputs.size(); int nLayers = int(layerWeights.size()); double pMSE; // unsigned long epc; double sumDeltas; nOutputs = getOutputSize(); // MultilayerPerceptron::TrainingResult tr; tres->time = 0; tres->epochs = 0; tres->MSEHistory.clear(); tres->MSE = getMSE(inputs, targets); tres->MSEHistory.push_back(tres->MSE); tres->RMSEHistory.clear(); tres->RMSE = getRMSE(inputs, targets); tres->RMSEHistory.push_back(tres->RMSE); tres->CEHistory.clear(); tres->CE = getCE(inputs, targets); tres->CEHistory.push_back(tres->CE); // tres.layerWeightsHistory.clear(); // tres.layerWeightsHistory.push_back(layerWeights); // tres.outputWeightsHistory.clear(); // tres.outputWeightsHistory.push_back(outputWeights); vector<vector<double> > layerOutputs; long double T = 0, sumDeltaF = 0, deltaF = 0, Pa = 0, avgDeltaF = 0; int c = 0; training = true; clock_t t_ini = clock(); do{ // tr.MSE = 0; // pMSE = 0; for(size_t p = 0; p < nPatterns; p++){ //Se obtienen las salidas para cada una de las capas layerOutputs = getLayerOutputs(inputs[p]); yObtained = layerOutputs[layerOutputs.size() - 1]; for(int layer = nLayers; layer >= 0; layer--){ nNeurons = (layer == nLayers ? outputWeights.size() : layerWeights[layer].size()); // deltaOut = vector<double>(nNeurons, 0); for(size_t neuron = 0; neuron <= nNeurons; neuron++){ //Se inicia el calculo de todos los deltas if(layer == nLayers){ //Si es la capa de salida if(neuron < nNeurons){ switch(tf){ case Sigmoid: deltaOut[neuron] = alfa * yObtained[neuron] * (1 - yObtained[neuron]) * (targets[p][neuron] - yObtained[neuron]); break; case Tanh: deltaOut[neuron] = alfa * (1 - (yObtained[neuron]*yObtained[neuron])) * (targets[p][neuron] - yObtained[neuron]); break; } }else{ continue; } }else{ size_t nDeltaElements = (layer == nLayers - 1 ? outputWeights.size() : layerWeights[layer + 1].size()); sumDeltas = 0; for(size_t element = 0; element < nDeltaElements; element++){ if(layer == nLayers - 1){ sumDeltas += deltaOut[element] * outputWeights[element][neuron]; }else{ sumDeltas += deltaHidden[layer+1][element] * layerWeights[layer+1][element][neuron]; } } switch(tf){ case Sigmoid: deltaHidden[layer][neuron] = alfa * layerOutputs[layer][neuron] * (1 - layerOutputs[layer][neuron]) * sumDeltas; break; case Tanh: deltaHidden[layer][neuron] = alfa * (1 - (layerOutputs[layer][neuron]*layerOutputs[layer][neuron])) * sumDeltas; break; } } } } //Comienza la actualizacion de los pesos for(int layer = nLayers; layer >= 0; layer--){ nNeurons = (layer == nLayers ? nOutputs : layerWeights[layer].size()); for(size_t i = 0; i < nNeurons; i++){ nBOutputs = (layer == 0 ? inputs[p].size() : layerWeights[layer - 1].size()); for(size_t j = 0; j <= nBOutputs; j++){ if(layer == nLayers){ outputWeights[i][j] += (j == nBOutputs ? -learningRate*deltaOut[i] : learningRate*deltaOut[i]*layerOutputs[layer-1][j]); }else if(layer == 0){ layerWeights[layer][i][j] += (j == nBOutputs ? -learningRate*deltaHidden[layer][i] : learningRate*deltaHidden[layer][i]*inputs[p][j]); }else{ layerWeights[layer][i][j] += (j == nBOutputs ? -learningRate*deltaHidden[layer][i] : learningRate*deltaHidden[layer][i]*layerOutputs[layer-1][j]); } } } } } pMSE = getMSE(inputs, targets); if(sa){//if Simulated annealing activated deltaF = pMSE - tres->MSE; sumDeltaF += deltaF; // Se calcula deltaF promedio c++; avgDeltaF = sumDeltaF / c; } tres->MSE = pMSE; tres->MSEHistory.push_back(tres->MSE); tres->RMSE = getRMSE(inputs, targets); tres->RMSEHistory.push_back(tres->RMSE); tres->CE = getCE(inputs, targets); tres->CEHistory.push_back(tres->CE); // tr.layerWeightsHistory.push_back(layerWeights); // tr.outputWeightsHistory.push_back(outputWeights); // epc++; if(sa){ if(fabs(avgDeltaF) < startCondition && c > 999){ // double avgDeltaF = sumDeltaF / c; // T = avgDeltaF / log(initialAcceptance); // T = 1 / log(initialAcceptance) * avgDeltaF; // T = deltaF / log(Pa); // T = -deltaF; // T = To; T = To; double fNew; NewState ns; // int n = 0; double fOld = tres->MSE; double rnd = 0; do{ for(unsigned int i = 0; i < nChanges; i++){ ns = addNoise(minNoise, maxNoise); fNew = getNewMSE(ns.newWeights, ns.newOutputWeights, inputs, targets); deltaF = fNew - fOld; Pa = exp(-deltaF/T); rnd = randomNumber(0,1); if(deltaF < 0 || rnd < Pa ){ layerWeights = ns.newWeights; outputWeights = ns.newOutputWeights; fOld = getMSE(inputs, targets); } } // T = T / (1 + n); T = tempDecFactor*T; // n++; }while(T > Tmin); c = 0; sumDeltaF = 0; } } tres->epochs++; }while(((tres->MSE >= MSEmin && sc == MSE) || (tres->RMSE >= RMSEmin && sc == RMSE) || (tres->CE >= CEmin && sc == CE)) && tres->epochs < epochs && training); training = false; tres->time = double(clock() - t_ini)/CLOCKS_PER_SEC; }
ValueCell::ValueCell( int x, int y ) : CellBase(x,y), my_value(randomNumber(MINVAL, MAXVAL)) { }
struct SVAThread * findNextFreeThread (void) { for (unsigned int index = 0; index < 4096; ++index) { if (__sync_bool_compare_and_swap (&(Threads[index].used), 0, 1)) { /* * Remember which thread is the one we've grabbed. */ struct SVAThread * newThread = Threads + index; /* * Do some basic initialization of the thread. */ newThread->integerState.valid = 0; newThread->savedICIndex = 0; newThread->ICFPIndex = 0; newThread->secmemSize = 0; newThread->numPushTargets = 0; newThread->secmemPML4e = 0; /* * This function currently sets the thread secret with a default * statically defined key. However, in the future will obtain said key * from the executable image. There is also some issue with * bootstrapping the initial key and whether or not on the first * execution of an application the key will need to be generated by SVA. * Thus, future design is yet to be done, however, the following function * should suffice to enable any of the above scenarios. * * TODO: The function currently uses a dummy static key, but in the * future will obtain the key from the executable image and then * decrypted with the VirtualGhost private key. */ if (vg) { init_thread_key(newThread); } #if DEBUG printf("<<<< SVA: Created new private key: value: %s\n", newThread->secret.key); #endif /* * Use the next-to-last interrupt context in the list as the first * interrupt context. This may be slightly wasteful, but it's a little * easier to make it work correctly right now. * * The processor's IST3 field should be configured so that the next * interrupt context is at maxIC - 2. */ sva_icontext_t * icontextp = newThread->interruptContexts + maxIC - 1; newThread->integerState.ist3 = ((uintptr_t) icontextp) - 0x10; newThread->integerState.kstackp = newThread->integerState.ist3; /* * Generate a random identifier for the new thread. */ if (vg) { newThread->rid = randomNumber(); } return newThread; } } panic ("SVA: findNextFreeThread: Exhausted SVA Threads!\n"); return 0; }
int test_prod(Epsilon const& epsilon) { int ret; viennacl::tools::uniform_random_numbers<NumericT> randomNumber; std::size_t matrix_size1 = 29; //some odd number, not too large std::size_t matrix_size2 = 47; //some odd number, not too large std::size_t matrix_size3 = 33; //some odd number, not too large //std::size_t matrix_size1 = 128; //some odd number, not too large //std::size_t matrix_size2 = 64; //some odd number, not too large //std::size_t matrix_size3 = 128; //some odd number, not too large //std::size_t matrix_size1 = 256; // for testing AMD kernels //std::size_t matrix_size2 = 256; // for testing AMD kernels //std::size_t matrix_size3 = 256; // for testing AMD kernels // -------------------------------------------------------------------------- // ublas reference: std::vector<std::vector<NumericT> > A(matrix_size1, std::vector<NumericT>(matrix_size2)); std::vector<std::vector<NumericT> > big_A(4*matrix_size1, std::vector<NumericT>(4*matrix_size2, NumericT(3.1415))); std::vector<std::vector<NumericT> > B(matrix_size2, std::vector<NumericT>(matrix_size3)); std::vector<std::vector<NumericT> > big_B(4*matrix_size2, std::vector<NumericT>(4*matrix_size3, NumericT(42.0))); std::vector<std::vector<NumericT> > C(matrix_size1, std::vector<NumericT>(matrix_size3)); //fill A and B: for (std::size_t i = 0; i < A.size(); ++i) for (std::size_t j = 0; j < A[0].size(); ++j) A[i][j] = static_cast<NumericT>(0.1) * randomNumber(); for (std::size_t i = 0; i < B.size(); ++i) for (std::size_t j = 0; j < B[0].size(); ++j) B[i][j] = static_cast<NumericT>(0.1) * randomNumber(); std::vector<std::vector<NumericT> > A_trans(A[0].size(), std::vector<NumericT>(A.size())); for (std::size_t i = 0; i < A.size(); ++i) for (std::size_t j = 0; j < A[0].size(); ++j) A_trans[j][i] = A[i][j]; std::vector<std::vector<NumericT> > big_A_trans(big_A[0].size(), std::vector<NumericT>(big_A.size())); for (std::size_t i = 0; i < big_A.size(); ++i) for (std::size_t j = 0; j < big_A[0].size(); ++j) big_A_trans[j][i] = big_A[i][j]; std::vector<std::vector<NumericT> > B_trans(B[0].size(), std::vector<NumericT>(B.size())); for (std::size_t i = 0; i < B.size(); ++i) for (std::size_t j = 0; j < B[0].size(); ++j) B_trans[j][i] = B[i][j]; std::vector<std::vector<NumericT> > big_B_trans(big_B[0].size(), std::vector<NumericT>(big_B.size())); for (std::size_t i = 0; i < big_B.size(); ++i) for (std::size_t j = 0; j < big_B[0].size(); ++j) big_B_trans[j][i] = big_B[i][j]; // // ViennaCL objects // // A viennacl::range range1_A(matrix_size1, 2*matrix_size1); viennacl::range range2_A(matrix_size2, 2*matrix_size2); viennacl::slice slice1_A(matrix_size1, 2, matrix_size1); viennacl::slice slice2_A(matrix_size2, 3, matrix_size2); viennacl::matrix<NumericT, F_A> vcl_A(matrix_size1, matrix_size2); viennacl::copy(A, vcl_A); viennacl::matrix<NumericT, F_A> vcl_big_range_A(4*matrix_size1, 4*matrix_size2); viennacl::matrix_range<viennacl::matrix<NumericT, F_A> > vcl_range_A(vcl_big_range_A, range1_A, range2_A); viennacl::copy(A, vcl_range_A); viennacl::matrix<NumericT, F_A> vcl_big_slice_A(4*matrix_size1, 4*matrix_size2); viennacl::matrix_slice<viennacl::matrix<NumericT, F_A> > vcl_slice_A(vcl_big_slice_A, slice1_A, slice2_A); viennacl::copy(A, vcl_slice_A); // A^T viennacl::matrix<NumericT, F_A> vcl_A_trans(matrix_size2, matrix_size1); viennacl::copy(A_trans, vcl_A_trans); viennacl::matrix<NumericT, F_A> vcl_big_range_A_trans(4*matrix_size2, 4*matrix_size1); viennacl::matrix_range<viennacl::matrix<NumericT, F_A> > vcl_range_A_trans(vcl_big_range_A_trans, range2_A, range1_A); viennacl::copy(A_trans, vcl_range_A_trans); viennacl::matrix<NumericT, F_A> vcl_big_slice_A_trans(4*matrix_size2, 4*matrix_size1); viennacl::matrix_slice<viennacl::matrix<NumericT, F_A> > vcl_slice_A_trans(vcl_big_slice_A_trans, slice2_A, slice1_A); viennacl::copy(A_trans, vcl_slice_A_trans); // B viennacl::range range1_B(2*matrix_size2, 3*matrix_size2); viennacl::range range2_B(2*matrix_size3, 3*matrix_size3); viennacl::slice slice1_B(matrix_size2, 3, matrix_size2); viennacl::slice slice2_B(matrix_size3, 2, matrix_size3); viennacl::matrix<NumericT, F_B> vcl_B(matrix_size2, matrix_size3); viennacl::copy(B, vcl_B); viennacl::matrix<NumericT, F_B> vcl_big_range_B(4*matrix_size2, 4*matrix_size3); viennacl::matrix_range<viennacl::matrix<NumericT, F_B> > vcl_range_B(vcl_big_range_B, range1_B, range2_B); viennacl::copy(B, vcl_range_B); viennacl::matrix<NumericT, F_B> vcl_big_slice_B(4*matrix_size2, 4*matrix_size3); viennacl::matrix_slice<viennacl::matrix<NumericT, F_B> > vcl_slice_B(vcl_big_slice_B, slice1_B, slice2_B); viennacl::copy(B, vcl_slice_B); // B^T viennacl::matrix<NumericT, F_B> vcl_B_trans(matrix_size3, matrix_size2); viennacl::copy(B_trans, vcl_B_trans); viennacl::matrix<NumericT, F_B> vcl_big_range_B_trans(4*matrix_size3, 4*matrix_size2); viennacl::matrix_range<viennacl::matrix<NumericT, F_B> > vcl_range_B_trans(vcl_big_range_B_trans, range2_B, range1_B); viennacl::copy(B_trans, vcl_range_B_trans); viennacl::matrix<NumericT, F_B> vcl_big_slice_B_trans(4*matrix_size3, 4*matrix_size2); viennacl::matrix_slice<viennacl::matrix<NumericT, F_B> > vcl_slice_B_trans(vcl_big_slice_B_trans, slice2_B, slice1_B); viennacl::copy(B_trans, vcl_slice_B_trans); // C viennacl::range range1_C(matrix_size1-1, 2*matrix_size1-1); viennacl::range range2_C(matrix_size3-1, 2*matrix_size3-1); viennacl::slice slice1_C(matrix_size1-1, 3, matrix_size1); viennacl::slice slice2_C(matrix_size3-1, 3, matrix_size3); viennacl::matrix<NumericT, F_C> vcl_C(matrix_size1, matrix_size3); viennacl::matrix<NumericT, F_C> vcl_big_range_C(4*matrix_size1, 4*matrix_size3); viennacl::matrix_range<viennacl::matrix<NumericT, F_C> > vcl_range_C(vcl_big_range_C, range1_C, range2_C); viennacl::matrix<NumericT, F_C> vcl_big_slice_C(4*matrix_size1, 4*matrix_size3); viennacl::matrix_slice<viennacl::matrix<NumericT, F_C> > vcl_slice_C(vcl_big_slice_C, slice1_C, slice2_C); std::cout << "--- Part 1: Testing matrix-matrix products ---" << std::endl; ////// ////// A: matrix ////// // // std::cout << "Now using A=matrix, B=matrix, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_B, vcl_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=matrix, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_B, vcl_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=matrix, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_B, vcl_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=range, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_range_B, vcl_range_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=range, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_range_B, vcl_range_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=range, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_range_B, vcl_range_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=slice, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=slice, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=slice, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; ////// ////// A: range ////// // // std::cout << "Now using A=range, B=matrix, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_B, vcl_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=matrix, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_B, vcl_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=matrix, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_B, vcl_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=range, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_range_B, vcl_range_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=range, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_range_B, vcl_range_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=range, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_range_B, vcl_range_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=slice, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=slice, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=slice, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; ////// ////// A: slice ////// // // std::cout << "Now using A=slice, B=matrix, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_B, vcl_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=matrix, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_B, vcl_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=matrix, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_B, vcl_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=range, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_range_B, vcl_range_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=range, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_range_B, vcl_range_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=range, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_range_B, vcl_range_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=slice, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=slice, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=slice, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; return ret; }
// Returns a random delay in units of 0.922 ms (the same units of radioMacRx). // This is used to decide when to next transmit a queued data packet. static uint8 randomTxDelay() { return 1 + (randomNumber() & 3); }
void planarTriconnectedGraph(Graph &G, int n, double p1, double p2) { if (n < 4) n = 4; // start with K_4 completeGraph(G,4); planarEmbedPlanarGraph(G); // nodes[0],...,nodes[i-1] is array of all nodes Array<node> nodes(n); node v; int i = 0; forall_nodes(v,G) nodes[i++] = v; for(; i < n; ++i) { // pick a random node v = nodes[randomNumber(0,i-1)]; int m = v->degree(); int a1 = randomNumber(0,m-1); int a2 = randomNumber(0,m-2); int j; adjEntry adj1, adj2; for(adj1 = v->firstAdj(), j = 0; j < a1; adj1 = adj1->succ(), ++j) ; for(adj2 = adj1->cyclicSucc(), j = 0; j < a2; adj2 = adj2->cyclicSucc(), ++j) ; adjEntry adj_b1 = adj2->cyclicPred(); adjEntry adj_b2 = adj1->cyclicPred(); nodes[i] = G.splitNode(adj1, adj2); if(adj1 == adj_b1) G.newEdge(adj_b1, adj2->twin()); else if(adj2 == adj_b2) G.newEdge(adj2, adj_b1->twin(), ogdf::before); else { double r = randomDouble(0.0,1.0); if(r <= p1) { int s = randomNumber(0,1); if(s == 0) G.newEdge(adj_b1, adj2->twin()); else G.newEdge(adj2, adj_b1->twin(), ogdf::before); } } double r = randomDouble(0.0,1.0); if(r <= p2) { int s = randomNumber(0,1); if(s == 0) G.newEdge(adj1, adj_b2->twin(), ogdf::before); else G.newEdge(adj_b2, adj1->twin()); } } }
void planarConnectedGraph(Graph &G, int n, int m) { if (n < 1) n = 1; if (m < n-1) m = n-1; if (m > 3*n-6) m = 3*n-6; G.clear(); Array<node> nodes(n); // we start with a triangle nodes[0] = G.newNode(); //build tree int i; for(i=1; i<n; ++i) { node on = nodes[randomNumber(0,i-1)]; node nn = nodes[i] = G.newNode(); G.firstNode()->degree(); if(on->degree() > 1) { adjEntry adj = on->firstAdj(); for(int fwd = randomNumber(0,on->degree()-1); fwd>0; --fwd) adj = adj->succ(); G.newEdge(nn, adj); } else { G.newEdge(nn, on); } } List<face> bigFaces; // not a triangle CombinatorialEmbedding E(G); bigFaces.pushBack(E.firstFace()); for(i = m-n+1; i-->0;) { ListIterator<face> fi = bigFaces.chooseIterator(); face f = *fi; bigFaces.del(fi); List<adjEntry> fnodes; adjEntry adj; forall_face_adj(adj, f) { fnodes.pushBack(adj); } fnodes.permute(); adjEntry adj1,adj2; bool okay = false; do { adj1 = fnodes.popFrontRet(); node n1 = adj1->theNode(); forall_listiterators(adjEntry, it, fnodes) { adj2 = *it; node n2 = adj2->theNode(); if(n1==n2 || adj1->faceCyclePred() == adj2 || adj2->faceCyclePred() == adj1) { continue; } edge e; okay = true; forall_adj_edges(e,n1) { if(e->opposite(n1) == n2) { okay = false; break; } } if(okay) break; } } while(!okay); edge ne = E.splitFace(adj1,adj2); face f1 = E.rightFace(ne->adjSource()); face f2 = E.rightFace(ne->adjTarget()); if (f1->size() > 3) bigFaces.pushBack(f1); if (f2->size() > 3) bigFaces.pushBack(f2); }
it("supports 3D", [&]() { GraphAttributes attr(*graph, GraphAttributes::nodeGraphics | GraphAttributes::nodeStyle | GraphAttributes::edgeGraphics | GraphAttributes::threeD | GraphAttributes::nodeLabel | GraphAttributes::nodeLabelPosition); List<node> nodes; graph->allNodes(nodes); nodes.permute(); int i = 0; for(node v : nodes) { attr.fillColor(v) = Color::Name::Gray; attr.x(v) = randomNumber(0, numberOfNodes*5); attr.y(v) = randomNumber(0, numberOfNodes*5); attr.label(v) = to_string(i); attr.z(v) = i++; } List<int> expected; for(i = 0; i < numberOfNodes; i++) { expected.pushBack(i); } pugi::xml_document doc; createDocument(attr, doc); pugi::xpath_node_set xmlNodes = doc.select_nodes("//text"); AssertThat(static_cast<int>(xmlNodes.size()), Equals(graph->numberOfNodes()));
int main(int args, char *argv[]) { char message[100]; MainPlayerData toPlayerData; CandidateData toCandidateData; StatusType status; fd_set allSocket; fd_set readfds; int fdmax, k, l; int n; int playerIndex; int mainPlayerSelected = 0; int clientId; int playerAnswer; int level; int numberOfClient = 0; int yes = 1; int readResult; int listener; int acceptSocket; struct sockaddr_in server, client; int sin_size; int socket_in_allSocket; int nbytes; int i, j; char clientName[40]; initializeClientList(); createCashPrizeList(); sin_size = sizeof(struct sockaddr_in); FD_ZERO(&allSocket); FD_ZERO(&readfds); if (args < 2) { printf("Usage : %s <PORT>\n", argv[0]); exit(-1); } readResult = readQuestionFile("question.txt"); if (readResult < 0) { printf("Can't load the questions !"); exit(-1); } if ((listener = socket(AF_INET, SOCK_STREAM, 0)) == -1) { printf("socket() error!\n"); exit(-1); } server.sin_family = AF_INET; server.sin_port = htons(atoi(argv[1])); server.sin_addr.s_addr = INADDR_ANY; bzero(&(server.sin_zero), 8); setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)); if (bind(listener, (struct sockaddr*) &server, sizeof(struct sockaddr)) == -1) { printf("bind() error!\n"); exit(-1); } //listen if (listen(listener, 2) == -1) { perror("listen"); exit(3); } FD_SET(listener, &allSocket); fdmax = listener; printf("\t<<<Gameshow GHE NONG - AI LA TRIEU PHU>>>\n"); while (1) { readfds = allSocket; /* On error, -1 is returned, select() and pselect() return the number of file descriptors */ if (mainPlayerSelected == 0) { if (select(fdmax + 1, &readfds, NULL, NULL, NULL ) == -1) { perror("select"); printf("errno = %d.\n", errno); exit(4); } } for (i = 0; i <= fdmax; i++) { if (FD_ISSET(i, &readfds)) { //printf("isset i=%d\n", i); if (i == listener) { acceptSocket = accept(listener, (struct sockaddr*) &client, &sin_size); printf("Listener : %d accept %d\n", listener, acceptSocket); //in dia chi ip printf("\n client address %s\n", inet_ntoa(client.sin_addr)); if (acceptSocket == -1) { perror("accept"); } else if (isClientListFull()) { clientId = NULL_ID; send(acceptSocket, &clientId, sizeof clientId, 0); close(acceptSocket); //FD_CLR(acceptSocket, &allSocket); } else { FD_SET(acceptSocket, &allSocket); printf("Server connected with socket %d\n", acceptSocket); addClient(acceptSocket); clientId = acceptSocket; if (acceptSocket > fdmax) { fdmax = acceptSocket; //printf("Now fdmax is : %d\n", fdmax); } send(acceptSocket, &clientId, sizeof clientId, 0); numberOfClient = getNumberOfClient(); printf("We're now having %d clients connected !\n", numberOfClient); } } else { // printf("i before switch = %d Fmax=%d\n", i, fdmax); switch_case: switch (getClientStatus(i)) { case CONNECTED: if ((nbytes = recv(i, &toCandidateData, sizeof toCandidateData, 0)) <= 0) { printf( "Server stopped connecting to client id %d\n", i); close(i); removeClient(i); printf("%d clients left !\n", getNumberOfClient()); FD_CLR(i, &allSocket); break; } else { recv(i, clientName, sizeof clientName, 0); setClientStatus(i, WAITING, clientName); strcpy(message, "Welcome : "); strcat(message, clientName); strcat(message, "\n"); strcpy(toCandidateData.message, message); toCandidateData.status = WAITING; send(i, &toCandidateData, sizeof toCandidateData, 0); printClientList(); /* check if have enough 6 clients, so we can start the game */ if (readyToStart()) { printf("We can start the game !!\n"); k = randomNumber(NUMBERS_PER_QUES); //send question to all the clients // for (j = 0; j < BACKLOG; j++) { setCompetition(j); copyQuestion(&(toCandidateData.question), questLib[0][k]); toCandidateData.ansTime = 0; toCandidateData.status = COMPETING; strcpy(toCandidateData.message, QUICK_QUESTION_MESSAGE); send(clientInfo[j].id, &toCandidateData, sizeof(CandidateData), 0); } //get the answer back from them // for (j = 0; j < BACKLOG; j++) { if (recv(clientInfo[j].id, &toCandidateData, sizeof toCandidateData, 0) <= 0) { printf( "Server stopped connecting to client id %d\n", i); close(i); removeClient(i); printf("%d clients left !\n", getNumberOfClient()); FD_CLR(i, &allSocket); } else { clientInfo[j].quick_answer = toCandidateData.answer; clientInfo[j].ansTime = toCandidateData.ansTime; } } //printf("Sending question done!\n"); printClientsAnswerList(); //select the main player // playerIndex = selectMainPlayer(questLib[0][k], BACKLOG); printf( "Our answer for the quick question : %d\n", questLib[0][k].ans); printf("====MAIN PLAYER SELECTED : %s ====\n", clientInfo[playerIndex].clientName); printClientStatus(clientInfo[playerIndex].id); startGame(playerIndex); for (j = 0; j < BACKLOG; j++) { if (j != playerIndex) { strcpy(toCandidateData.message, JOINER_MESSAGE); } else { strcpy(toCandidateData.message, MAIN_PLAYER_SELECTED); strcpy(toPlayerData.name, clientInfo[j].clientName); } toCandidateData.status = getClientStatus( clientInfo[j].id); send(clientInfo[j].id, &toCandidateData, sizeof(CandidateData), 0); } printClientList(); //printf("Current i = %d\n", i); i = clientInfo[playerIndex].id; mainPlayerSelected = 1; goto switch_case; // break; } else { sprintf(message, "We now have %d players online, please wait until we have more %d client(s) !\n", getNumberOfClient(), BACKLOG - getNumberOfClient()); strcpy(toCandidateData.message, message); send(i, &toCandidateData, sizeof toCandidateData, 0); } } break; case JOINING: //printf("[JOINING] Current i = %d\n", i); // i = 0; // if (mainPlayerSelected == 1) { // if ((nbytes = recv(i, &toCandidateData, // sizeof toCandidateData, 0)) <= 0) { // printf( // "Server stopped connecting to client id %d\n", // i); // close(i); // removeClient(i); // printf("%d clients left !\n", // getNumberOfClient()); // FD_CLR(i, &allSocket); // break; // } // } break; case PLAYING: mainPlayerSelected = 1; initializeMainPlayerData(&toPlayerData); level = 1; do { selectQuestion(level, &toPlayerData); send(clientInfo[playerIndex].id, &toPlayerData, sizeof toPlayerData, 0); for (n = 0; n < BACKLOG; n++) { if (clientInfo[n].status == JOINING) { send(clientInfo[n].id, &toPlayerData, sizeof toPlayerData, 0); } } if (recv(i, &playerAnswer, sizeof playerAnswer, 0) <= 0) { printf( "Server stopped connecting to client id %d\n", i); close(i); removeClient(i); printf("%d clients left !\n", getNumberOfClient()); FD_CLR(i, &allSocket); gameFinish(&toPlayerData,END); for (n = 0; n < BACKLOG; n++) { if (clientInfo[n].status == JOINING) { toPlayerData.status = FINISHED; send(clientInfo[n].id, &toPlayerData, sizeof toPlayerData, 0); close(clientInfo[n].id); removeClient(clientInfo[n].id); FD_CLR(clientInfo[n].id, &allSocket); } } continue; } if (playerAnswer == RIGHT) { printf("Good job! The player gave a right answer!\n"); increaseQuestion(&toPlayerData); //tra loi dung o cau hoi so 15 if (level == MAX_LEVEL) { wonGame(&toPlayerData); send(i, &toPlayerData, sizeof toPlayerData, 0); for (n = 0; n < BACKLOG; n++) { if (clientInfo[n].status == JOINING) { send(clientInfo[n].id, &toPlayerData, sizeof toPlayerData, 0); close(clientInfo[n].id); removeClient(clientInfo[n].id); FD_CLR(clientInfo[n].id, &allSocket); } } close(i); removeClient(i); FD_CLR(i, &allSocket); exit(1); } level = level + 1; } else { endGame(&toPlayerData, playerAnswer); gameFinish(&toPlayerData,playerAnswer); send(i, &toPlayerData, sizeof toPlayerData, 0); for (n = 0; n < BACKLOG; n++) { if (clientInfo[n].status == JOINING) { toPlayerData.status = FINISHED; send(clientInfo[n].id, &toPlayerData, sizeof toPlayerData, 0); close(clientInfo[n].id); removeClient(clientInfo[n].id); FD_CLR(clientInfo[n].id, &allSocket); } } close(i); removeClient(i); printf("%d clients left !\n", getNumberOfClient()); FD_CLR(i, &allSocket); } } while (playerAnswer == RIGHT && level <= MAX_LEVEL); printf("The game of player : %s ended !\n", toPlayerData.name); exit(1); break; default: break; } } } } } }
/** Generate full table. */ void generateTable() { int i; long base, addT, altT, lastT; long checkSum = 0; /* larger trials (n=262144 to 2097152) if desired. */ /* Trials */ int MAX_SIZE = 1048576; int NUM_TRIALS = 10000; n = 256; while (n <= MAX_SIZE) { int *n1, *n2, *sum, *copy1, *copy2; printf ("Trying %d...\n", n); /* generate numbers and space for storage */ n1 = calloc (n, sizeof (int)); n2 = calloc (n, sizeof (int)); randomNumber(n1); randomNumber(n2); sum = calloc (n+1, sizeof (int)); copy1= calloc (n, sizeof (int)); copy2= calloc (n, sizeof (int)); bcopy (n1, copy1, n); bcopy (n2, copy2, n); /** Timing as follows: * * gettimeofday(&before, (struct timezone *) NULL); BEGIN * OP HERE * gettimeofday(&after, (struct timezone *) NULL); END * * long usecs = diffTimer (&before, &after); SHOW RESULTS * report (usecs); */ /* BASELINE*/ gettimeofday(&before, (struct timezone *) NULL); for (i = 0; i < NUM_TRIALS; i++) { int c; /* NOP */ checkSum += n1[0]; /* circular shift (n1 left, n2 right). */ c = n1[0]; bcopy (n1+1, n1, n-1); n1[n-1] = c; c = n2[n-1]; bcopy (n2, n2+1, n-1); n2[0] = c; } gettimeofday(&after, (struct timezone *) NULL); base = diffTimer (&before, &after); /* ADD */ bcopy (copy1, n1, n); bcopy (copy2, n2, n); gettimeofday(&before, (struct timezone *) NULL); for (i = 0; i < NUM_TRIALS; i++) { int c; add(n1,n2,sum); checkSum += sum[0]; /* circular shift (n1 left, n2 right). */ c = n1[0]; bcopy (n1+1, n1, n-1); n1[n-1] = c; c = n2[n-1]; bcopy (n2, n2+1, n-1); n2[0] = c; } gettimeofday(&after, (struct timezone *) NULL); addT = diffTimer (&before, &after); /* ALT */ bcopy (copy1, n1, n); bcopy (copy2, n2, n); for (i = 0; i < NUM_TRIALS; i++) { int c; alt(n1,n2,sum); checkSum += sum[0]; /* circular shift (n1 left, n2 right). */ c = n1[0]; bcopy (n1+1, n1, n-1); n1[n-1] = c; c = n2[n-1]; bcopy (n2, n2+1, n-1); n2[0] = c; } gettimeofday(&after, (struct timezone *) NULL); altT = diffTimer (&before, &after); /* LAST */ bcopy (copy1, n1, n); bcopy (copy2, n2, n); gettimeofday(&before, (struct timezone *) NULL); for (i = 0; i < NUM_TRIALS; i++) { int c; last(n1,n2,sum); checkSum += sum[0]; /* circular shift (n1 left, n2 right). */ c = n1[0]; bcopy (n1+1, n1, n-1); n1[n-1] = c; c = n2[n-1]; bcopy (n2, n2+1, n-1); n2[0] = c; } gettimeofday(&after, (struct timezone *) NULL); lastT = diffTimer (&before, &after); report (lastT); printf("%d,Base:%ld,ms.\n", n, base/1000); printf("%d,Add*:%ld,ms.\n", n, (addT-base)/1000); printf("%d,Alt*:%ld,ms.\n", n, (altT-base)/1000); printf("%d,Last*:%ld,ms.\n", n, (lastT-base)/1000); /* advance */ n = n * 2; free(n1); free(n2); free(copy1); free(copy2); free(sum); } printf ("Checksum:%ld\n", checkSum); }
static RANDOM_FOREST * train_rforest(MRI *mri_inputs[MAX_SUBJECTS][MAX_TIMEPOINTS], MRI *mri_segs[MAX_SUBJECTS][MAX_TIMEPOINTS], TRANSFORM *transforms[MAX_SUBJECTS][MAX_TIMEPOINTS], int nsubjects, GCA *gca, RFA_PARMS *parms, float wm_thresh, int wmsa_whalf, int ntp) { RANDOM_FOREST *rf ; int nfeatures, x, y, z, ntraining, n, tvoxel_size, width, height, depth, xt, yt, zt ; double xatlas, yatlas, zatlas ; MRI *mri_in, *mri_seg, *mri_training_voxels, *mri_wmsa_possible ; TRANSFORM *transform ; double **training_data ; int *training_classes, i, label, tlabel, nwmsa, nfuture, nnot, correct, label_time1, label_time2; nwmsa = nnot = nfuture = 0 ; /* features are: t1 intensity (3 vols) 3 priors # of unknown voxels in the nbhd # of neighboring wmsa voxels at t1 */ nfeatures = parms->wsize*parms->wsize*parms->wsize*parms->nvols + 5 ; rf = RFalloc(parms->ntrees, nfeatures, NCLASSES, parms->max_depth, single_classifier_names, max_steps) ; if (rf == NULL) ErrorExit(ERROR_NOFILE, "%s: could not allocate random forest", Progname) ; rf->min_step_size = 1 ; tvoxel_size=1 ; width = (int)ceil((float)mri_segs[0][0]->width/tvoxel_size) ; height = (int)ceil((float)mri_segs[0][0]->height/tvoxel_size) ; depth = (int)ceil((float)mri_segs[0][0]->depth/tvoxel_size) ; mri_wmsa_possible = MRIalloc(width, height, depth, MRI_UCHAR) ; GCAcopyDCToMRI(gca, mri_wmsa_possible) ; mri_in = mri_inputs[0][0] ; mri_training_voxels = MRIallocSequence(mri_in->width,mri_in->height, mri_in->depth,MRI_UCHAR,nsubjects) ; #if 1 // update time 1 segmentation based on labels at time1 and time2 for (n = 0 ; n < nsubjects ; n++) { mri_seg = mri_segs[n][0] ; for (x = 0 ; x < mri_in->width ; x++) for (y = 0 ; y < mri_in->height ; y++) for (z = 0 ; z < mri_in->depth ; z++) { label_time1 = MRIgetVoxVal(mri_segs[n][0], x, y, z, 0) ; label_time2 = MRIgetVoxVal(mri_segs[n][1], x, y, z, 0) ; if (IS_WMSA(label_time1)) MRIsetVoxVal(mri_segs[n][0], x, y, z, 0, label_time1) ; else if (IS_WMSA(label_time2)) MRIsetVoxVal(mri_segs[n][0], x, y, z, 0, future_WMSA) ; } } #endif // build map of spatial locations that WMSAs can possibly occur in for (n = 0 ; n < nsubjects ; n++) { mri_in = mri_inputs[n][1] ; transform = transforms[n][1] ; for (x = 0 ; x < mri_in->width ; x++) for (y = 0 ; y < mri_in->height ; y++) for (z = 0 ; z < mri_in->depth ; z++) if (is_possible_wmsa(gca, mri_in, transform, x, y, z, 0)) { TransformSourceVoxelToAtlas(transform, mri_in, x, y, z, &xatlas, &yatlas, &zatlas) ; xt = nint(xatlas/tvoxel_size) ; yt = nint(yatlas/tvoxel_size) ; zt = nint(zatlas/tvoxel_size) ; if (xt == Gx && yt == Gy && zt == Gz) DiagBreak() ; MRIsetVoxVal(mri_wmsa_possible, xt, yt, zt, 0, 1) ; } } for ( ; wmsa_whalf > 0 ; wmsa_whalf--) MRIdilate(mri_wmsa_possible, mri_wmsa_possible) ; // now build map of all voxels in training set for (nnot = nwmsa = nfuture = ntraining = n = 0 ; n < nsubjects ; n++) { mri_in = mri_inputs[n][0] ; mri_seg = mri_segs[n][0] ; transform = transforms[n][0] ; for (x = 0 ; x < mri_in->width ; x++) for (y = 0 ; y < mri_in->height; y++) for (z = 0 ; z < mri_in->depth; z++) { label = MRIgetVoxVal(mri_seg, x, y, z, 0) ; TransformSourceVoxelToAtlas(transform, mri_in, x, y, z, &xatlas, &yatlas, &zatlas) ; xt = nint(xatlas/tvoxel_size) ; yt = nint(yatlas/tvoxel_size) ; zt = nint(zatlas/tvoxel_size) ; if (xt == Gx && yt == Gy && zt == Gz) DiagBreak() ; if ((IS_WMSA(label) == 0) && MRIgetVoxVal(mri_wmsa_possible,xt,yt, zt,0) == 0) continue ; if (NOT_TRAINING_LABEL(label)) continue ; ntraining++ ; if (IS_FUTURE_WMSA(label)) { label = FUTURE_WMSA; nfuture++ ; } else if (IS_WMSA(label)) { label = WMSA ; nwmsa++ ; } else { label = NOT_WMSA ; nnot++ ; } // set label to one more than it will be for training so that 0 means this is not a training voxel MRIsetVoxVal(mri_training_voxels, x, y, z, n, label+1) ; } } correct = MRIcountNonzero(mri_training_voxels) ; if (correct != ntraining) DiagBreak() ; printf("total training set size = %2.1fM\n", (float)ntraining/(1024.0f*1024.0f)) ; printf("initial training set found with %dK FUTURE WMSA labels, %dK WMSA labels, and %dK non (ratio=%2.1f:%2.1f)\n", nfuture/1000, nwmsa/1000, nnot/1000, (float)nnot/(float)nfuture, (float)nnot/(float)nwmsa) ; MRIfree(&mri_wmsa_possible) ; if (max_wm_wmsa_ratio*(nfuture+nwmsa) < nnot) // too many wm labels w.r.t. # of wmsas - remove some wm { int removed, total_to_remove = nnot - (max_wm_wmsa_ratio*(nfuture+nwmsa)) ; double premove ; premove = (double)total_to_remove / (double)nnot ; printf("removing %dK WM indices to reduce training set imbalance (p < %f)\n", total_to_remove/1000, premove) ; for (removed = n = 0 ; n < nsubjects ; n++) for (x = 0 ; x < mri_in->width ; x++) for (y = 0 ; y < mri_in->height; y++) for (z = 0 ; z < mri_in->depth; z++) { label = MRIgetVoxVal(mri_training_voxels, x, y, z, n) ; if (label == 1) // a WM voxel { if (randomNumber(0,1) < premove) { removed++ ; MRIsetVoxVal(mri_training_voxels, x, y, z, n, 0) ; // remove it from training set } } } ntraining -= removed ; printf("%d WM voxels removed, new training set size = %dM (ratio = %2.1f)\n", removed, ntraining/(1024*1024), (double)(nnot-removed)/(double)(nwmsa+nfuture)) ; } correct = MRIcountNonzero(mri_training_voxels) ; if (correct != ntraining) DiagBreak() ; // if (Gx >= 0) { int whalf = (parms->wsize-1)/2 ; char buf[STRLEN] ; rf->feature_names = (char **)calloc(rf->nfeatures, sizeof(char *)) ; for (i = 0, x = -whalf ; x <= whalf ; x++) for (y = -whalf ; y <= whalf ; y++) for (z = -whalf ; z <= whalf ; z++) for (n = 0 ; n < mri_in->nframes ; n++, i++) { switch (n) { default: case 0: sprintf(buf, "T1(%d, %d, %d)", x, y, z) ; break ; case 1: sprintf(buf, "T2(%d, %d, %d)", x, y, z) ; break ; case 2: sprintf(buf, "FLAIR(%d, %d, %d)", x, y, z) ; if (x == 0 && y == 0 && z == 0) Gdiag_no = i ; break ; } rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ; strcpy(rf->feature_names[i], buf) ; } printf("FLAIR(0,0,0) = %dth feature\n", Gdiag_no) ; sprintf(buf, "CSF voxels in nbhd") ; rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ; strcpy(rf->feature_names[i], buf) ; i++ ; sprintf(buf, "gm prior") ; rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ; strcpy(rf->feature_names[i], buf) ; i++ ; sprintf(buf, "wm prior") ; rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ; strcpy(rf->feature_names[i], buf) ; i++ ; sprintf(buf, "csf prior") ; rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ; strcpy(rf->feature_names[i], buf) ; i++ ; sprintf(buf, "WMSA in nbhd") ; rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ; strcpy(rf->feature_names[i], buf) ; if (Gdiag & DIAG_WRITE) { printf("writing training voxels to tv.mgz\n") ; MRIwrite(mri_training_voxels, "tv.mgz") ; } } // now build training features and classes training_classes = (int *)calloc(ntraining, sizeof(training_classes[0])) ; if (training_classes == NULL) ErrorExit(ERROR_NOFILE, "train_rforest: could not allocate %d-length training buffers",ntraining); training_data = (double **)calloc(ntraining, sizeof(training_data[0])) ; if (training_classes == NULL) ErrorExit(ERROR_NOFILE, "train_rforest: could not allocate %d-length training buffers",ntraining); for (i = n = 0 ; n < nsubjects ; n++) { mri_in = mri_inputs[n][0] ; mri_seg = mri_segs[n][0] ; transform = transforms[n][0] ; for (x = 0 ; x < mri_in->width ; x++) for (y = 0 ; y < mri_in->height; y++) for (z = 0 ; z < mri_in->depth; z++) { if ((int)MRIgetVoxVal(mri_training_voxels, x, y, z, n) == 0) continue ; label = MRIgetVoxVal(mri_seg, x, y, z, 0) ; TransformSourceVoxelToAtlas(transform, mri_in, x, y, z, &xatlas, &yatlas, &zatlas) ; xt = nint(xatlas/tvoxel_size) ; yt = nint(yatlas/tvoxel_size) ; zt = nint(zatlas/tvoxel_size) ; if (IS_FUTURE_WMSA(label)) tlabel = FUTURE_WMSA ; else if (IS_WMSA(label)) tlabel = WMSA ; else tlabel= NOT_WMSA ; training_classes[i] = tlabel ; training_data[i] = (double *)calloc(nfeatures, sizeof(double)) ; if (training_data[i] == NULL) ErrorExit(ERROR_NOMEMORY, "train_rforest: could not allocate %d-len feature vector #%d", nfeatures, i) ; training_classes[i] = training_classes[i] ; // extract_feature(mri_in, parms->wsize, x, y, z, training_data[i], xatlas, yatlas, zatlas) ; extract_long_features(mri_in, mri_seg, transform, gca, parms->wsize, x, y, z, training_data[i]) ; if (training_data[i][Gdiag_no] < 80 && training_classes[i] == 1) DiagBreak() ; i++ ; } MRIfree(&mri_in) ; MRIfree(&mri_seg) ; TransformFree(&transform) ; } if (i < ntraining) { printf("warning!!!! i (%d) < ntraining (%d)! Setting ntraining=i\n", i, ntraining) ; ntraining = i ; } printf("training random forest with %dK FUTURE WMSA labels, %dK WMSA labels, and %dK non (ratio=%2.1f:%2.1f)\n", nfuture/1000, nwmsa/1000, nnot/1000, (float)nnot/(float)nfuture, (float)nnot/(float)nwmsa) ; RFtrain(rf, parms->feature_fraction, parms->training_fraction, training_classes, training_data, ntraining); correct = RFcomputeOutOfBagCorrect(rf, training_classes, training_data,ntraining); printf("out of bag accuracy: %d of %d = %2.2f%%\n", correct, ntraining, 100.0*correct/ntraining) ; if (log_file_name) { struct flock fl; int fd; char line[MAX_LINE_LEN] ; printf("writing results to train.log file %s\n", log_file_name) ; fd = open(log_file_name, O_WRONLY|O_APPEND|O_CREAT, S_IRWXU|S_IRWXG); if (fd < 0) ErrorExit(ERROR_NOFILE, "%s: could not open test log file %s", Progname, log_file_name); fcntl(fd, F_SETLKW, &fl); /* F_GETLK, F_SETLK, F_SETLKW */ sprintf(line, "%f %d %d %f\n", rf->training_fraction, rf->max_depth, rf->ntrees, 100.0*correct/ntraining) ; write(fd, line, (strlen(line))*sizeof(char)) ; fl.l_type = F_UNLCK; /* tell it to unlock the region */ fcntl(fd, F_SETLK, &fl); /* set the region to unlocked */ close(fd) ; } for (i = 0 ; i < ntraining ; i++) // allow for augmenting with other wmsa examples free(training_data[i]) ; free(training_data) ; free(training_classes) ; MRIfree(&mri_training_voxels) ; return(rf) ; }
void planarCNBGraph(Graph &G, int n, int m, int b) { G.clear(); if (b <= 0) b = 1; if (n <= 0) n = 1; if ((m <= 0) || (m > 3*n-6)) m = 3*n-6; node cutv; G.newNode(); for (int nB=1; nB<=b; nB++){ cutv = G.chooseNode(); // set number of nodes for the current created block int actN = randomNumber(1, n); node v1 = G.newNode(); if (actN <= 1){ G.newEdge(v1, cutv); } else if (actN == 2){ node v2 = G.newNode(); G.newEdge(v1, v2); int rnd = randomNumber(1, 2); edge newE; int rnd2 = randomNumber(1, 2); if (rnd == 1){ newE = G.newEdge(v1, cutv); } else{ newE = G.newEdge(v2, cutv); } if (rnd2 == 1){ G.contract(newE); } } else{ // set number of edges for the current created block int actM; if (m > 3*actN-6) actM = randomNumber(1, 3*actN-6); else actM = randomNumber(1, m); if (actM < actN) actM = actN; int ke = actN-3, kf = actM-actN; Array<node> nodes(actN); Array<edge> edges(actM); Array<face> bigFaces(actM); // we start with a triangle node v2 = G.newNode(), v3 = G.newNode(); nodes[0] = v1; nodes[1] = v2; nodes[2] = v3; edges[0] = G.newEdge(v1,v2); edges[1] = G.newEdge(v2,v3); edges[2] = G.newEdge(v3,v1); int actInsertedNodes = 3; CombinatorialEmbedding E(G); FaceArray<int> posBigFaces(E); int nBigFaces = 0, nEdges = 3; while(ke+kf > 0) { int p = randomNumber(1,ke+kf); if (nBigFaces == 0 || p <= ke) { int eNr = randomNumber(0,nEdges-1); edge e = edges[eNr]; face f = E.rightFace(e->adjSource()); face fr = E.rightFace(e->adjTarget()); node u = e->source(); node v = e->target(); edges[nEdges++] = E.split(e); if (e->source() != v && e->source() != u) nodes[actInsertedNodes++] = e->source(); else nodes[actInsertedNodes++] = e->target(); if (f->size() == 4) { posBigFaces[f] = nBigFaces; bigFaces[nBigFaces++] = f; } if (fr->size() == 4) { posBigFaces[fr] = nBigFaces; bigFaces[nBigFaces++] = fr; } ke--; } else { int pos = randomNumber(0,nBigFaces-1); face f = bigFaces[pos]; int df = f->size(); int i = randomNumber(0,df-1), j = randomNumber(2,df-2); adjEntry adj1; for (adj1 = f->firstAdj(); i > 0; adj1 = adj1->faceCycleSucc()) i--; adjEntry adj2; for (adj2 = adj1; j > 0; adj2 = adj2->faceCycleSucc()) j--; edge e = E.splitFace(adj1,adj2); edges[nEdges++] = e; face f1 = E.rightFace(e->adjSource()); face f2 = E.rightFace(e->adjTarget()); bigFaces[pos] = f1; posBigFaces[f1] = pos; if (f2->size() >= 4) { posBigFaces[f2] = nBigFaces; bigFaces[nBigFaces++] = f2; } if (f1->size() == 3) { bigFaces[pos] = bigFaces[--nBigFaces]; } kf--; } } // delete multi edges SListPure<edge> allEdges; EdgeArray<int> minIndex(G), maxIndex(G); parallelFreeSortUndirected(G,allEdges,minIndex,maxIndex); SListConstIterator<edge> it = allEdges.begin(); edge ePrev = *it, e; for(it = ++it; it.valid(); ++it, ePrev = e) { e = *it; if (minIndex[ePrev] == minIndex[e] && maxIndex[ePrev] == maxIndex[e]) { G.move(e, e->adjTarget()->faceCycleSucc()->twin(), ogdf::before, e->adjSource()->faceCycleSucc()->twin(), ogdf::before); } } node cutv2 = nodes[randomNumber(0,actN-1)]; int rnd = randomNumber(1,2); edge newE = G.newEdge(cutv2, cutv); if (rnd == 1){ G.contract(newE); } } } };
void planarBiconnectedGraph(Graph &G, int n, int m, bool multiEdges) { if (n < 3) n = 3; if (m < n) m = n; if (m > 3*n-6) m = 3*n-6; int ke = n-3, kf = m-n; G.clear(); Array<edge> edges(m); Array<face> bigFaces(m); //random_source S; // we start with a triangle node v1 = G.newNode(), v2 = G.newNode(), v3 = G.newNode(); edges[0] = G.newEdge(v1,v2); edges[1] = G.newEdge(v2,v3); edges[2] = G.newEdge(v3,v1); CombinatorialEmbedding E(G); FaceArray<int> posBigFaces(E); int nBigFaces = 0, nEdges = 3; while(ke+kf > 0) { int p = randomNumber(1,ke+kf); if (nBigFaces == 0 || p <= ke) { edge e = edges[randomNumber(0,nEdges-1)]; face f = E.rightFace(e->adjSource()); face fr = E.rightFace(e->adjTarget()); edges[nEdges++] = E.split(e); if (f->size() == 4) { posBigFaces[f] = nBigFaces; bigFaces[nBigFaces++] = f; } if (fr->size() == 4) { posBigFaces[fr] = nBigFaces; bigFaces[nBigFaces++] = fr; } ke--; } else { int pos = randomNumber(0,nBigFaces-1); face f = bigFaces[pos]; int df = f->size(); int i = randomNumber(0,df-1), j = randomNumber(2,df-2); adjEntry adj1; for (adj1 = f->firstAdj(); i > 0; adj1 = adj1->faceCycleSucc()) i--; adjEntry adj2; for (adj2 = adj1; j > 0; adj2 = adj2->faceCycleSucc()) j--; edge e = E.splitFace(adj1,adj2); edges[nEdges++] = e; face f1 = E.rightFace(e->adjSource()); face f2 = E.rightFace(e->adjTarget()); bigFaces[pos] = f1; posBigFaces[f1] = pos; if (f2->size() >= 4) { posBigFaces[f2] = nBigFaces; bigFaces[nBigFaces++] = f2; } if (f1->size() == 3) { bigFaces[pos] = bigFaces[--nBigFaces]; } kf--; } } if (multiEdges == false) { SListPure<edge> allEdges; EdgeArray<int> minIndex(G), maxIndex(G); parallelFreeSortUndirected(G,allEdges,minIndex,maxIndex); SListConstIterator<edge> it = allEdges.begin(); edge ePrev = *it, e; for(it = ++it; it.valid(); ++it, ePrev = e) { e = *it; if (minIndex[ePrev] == minIndex[e] && maxIndex[ePrev] == maxIndex[e]) { G.move(e, e->adjTarget()->faceCycleSucc()->twin(), ogdf::before, e->adjSource()->faceCycleSucc()->twin(), ogdf::before); } } } }
int Weapon::getDamage() { return randomNumber(min_attack, max_attack); }
int test(NumericT epsilon) { std::size_t N = 142; // should be larger than 128 in order to avoid false negatives due to blocking viennacl::tools::uniform_random_numbers<NumericT> randomNumber; // // Vector setup and test: // std::vector<NumericT> std_x(N); std::vector<NumericT> std_y(N); std::vector<NumericT> std_z(N); for (std::size_t i=0; i<std_x.size(); ++i) std_x[i] = NumericT(i + 1); for (std::size_t i=0; i<std_y.size(); ++i) std_y[i] = NumericT(i*i + 1); for (std::size_t i=0; i<std_z.size(); ++i) std_z[i] = NumericT(2 * i + 1); viennacl::vector<NumericT> vcl_x; viennacl::vector<NumericT> vcl_y; viennacl::vector<NumericT> vcl_z; viennacl::copy(std_x, vcl_x); viennacl::copy(std_y, vcl_y); viennacl::copy(std_z, vcl_z); // This shouldn't do anything bad: vcl_x = vcl_x; check(std_x, vcl_x, "x = x", epsilon); // This should work, even though we are dealing with the same buffer: std_x[0] = std_x[2]; std_x[1] = std_x[3]; viennacl::project(vcl_x, viennacl::range(0, 2)) = viennacl::project(vcl_x, viennacl::range(2, 4)); check(std_x, vcl_x, "x = x (range)", epsilon); // // Matrix-Vector // std::vector<std::vector<NumericT> > std_A(N, std::vector<NumericT>(N, NumericT(1))); std::vector<std::vector<NumericT> > std_B(N, std::vector<NumericT>(N, NumericT(2))); std::vector<std::vector<NumericT> > std_C(N, std::vector<NumericT>(N, NumericT(3))); viennacl::matrix<NumericT> vcl_A; viennacl::matrix<NumericT> vcl_B; viennacl::matrix<NumericT> vcl_C; viennacl::copy(std_A, vcl_A); viennacl::copy(std_B, vcl_B); viennacl::copy(std_C, vcl_C); // This shouldn't do anything bad: vcl_A = vcl_A; check(std_A, vcl_A, "A = A", epsilon); // This should work, even though we are dealing with the same buffer: std_A[0][0] = std_A[0][2]; std_A[0][1] = std_A[0][3]; viennacl::project(vcl_A, viennacl::range(0, 1), viennacl::range(0, 2)) = viennacl::project(vcl_A, viennacl::range(0, 1), viennacl::range(2, 4)); check(std_A, vcl_A, "A = A (range)", epsilon); // check x <- A * x; for (std::size_t i = 0; i<std_y.size(); ++i) { NumericT val = 0; for (std::size_t j = 0; j<std_x.size(); ++j) val += std_A[i][j] * std_x[j]; std_y[i] = val; } vcl_x = viennacl::linalg::prod(vcl_A, vcl_x); check(std_y, vcl_x, "x = A*x", epsilon); typedef unsigned int KeyType; std::vector< std::map<KeyType, NumericT> > std_Asparse(N); for (std::size_t i=0; i<std_Asparse.size(); ++i) { if (i > 0) std_Asparse[i][KeyType(i-1)] = randomNumber(); std_Asparse[i][KeyType(i)] = NumericT(1) + randomNumber(); if (i < std_Asparse.size() - 1) std_Asparse[i][KeyType(i+1)] = randomNumber(); } // Sparse viennacl::compressed_matrix<NumericT> vcl_A_csr; viennacl::coordinate_matrix<NumericT> vcl_A_coo; viennacl::ell_matrix<NumericT> vcl_A_ell; viennacl::sliced_ell_matrix<NumericT> vcl_A_sell; viennacl::hyb_matrix<NumericT> vcl_A_hyb; viennacl::copy(std_Asparse, vcl_A_csr); viennacl::copy(std_Asparse, vcl_A_coo); viennacl::copy(std_Asparse, vcl_A_ell); viennacl::copy(std_Asparse, vcl_A_sell); viennacl::copy(std_Asparse, vcl_A_hyb); for (std::size_t i=0; i<std_Asparse.size(); ++i) { NumericT val = 0; for (typename std::map<unsigned int, NumericT>::const_iterator it = std_Asparse[i].begin(); it != std_Asparse[i].end(); ++it) val += it->second * std_x[it->first]; std_y[i] = val; } viennacl::copy(std_x, vcl_x); vcl_x = viennacl::linalg::prod(vcl_A_csr, vcl_x); check(std_y, vcl_x, "x = A*x (sparse, csr)", epsilon); viennacl::copy(std_x, vcl_x); vcl_x = viennacl::linalg::prod(vcl_A_coo, vcl_x); check(std_y, vcl_x, "x = A*x (sparse, coo)", epsilon); viennacl::copy(std_x, vcl_x); vcl_x = viennacl::linalg::prod(vcl_A_ell, vcl_x); check(std_y, vcl_x, "x = A*x (sparse, ell)", epsilon); viennacl::copy(std_x, vcl_x); vcl_x = viennacl::linalg::prod(vcl_A_sell, vcl_x); check(std_y, vcl_x, "x = A*x (sparse, sell)", epsilon); viennacl::copy(std_x, vcl_x); vcl_x = viennacl::linalg::prod(vcl_A_hyb, vcl_x); check(std_y, vcl_x, "x = A*x (sparse, hyb)", epsilon); std::cout << std::endl; // // Matrix-Matrix (dense times dense): // test_gemm<op_assign>(epsilon, std_A, std_B, std_C, vcl_A, "A", vcl_B, "B", vcl_A, true); test_gemm<op_assign>(epsilon, std_B, std_A, std_C, vcl_B, "B", vcl_A, "A", vcl_A, false); test_gemm<op_assign>(epsilon, std_A, std_A, std_C, vcl_A, "A", vcl_A, "A", vcl_A, true); std::cout << std::endl; test_gemm<op_plus_assign>(epsilon, std_A, std_B, std_C, vcl_A, "A", vcl_B, "B", vcl_A, true); test_gemm<op_plus_assign>(epsilon, std_B, std_A, std_C, vcl_B, "B", vcl_A, "A", vcl_A, false); test_gemm<op_plus_assign>(epsilon, std_A, std_A, std_C, vcl_A, "A", vcl_A, "A", vcl_A, true); std::cout << std::endl; test_gemm<op_minus_assign>(epsilon, std_A, std_B, std_C, vcl_A, "A", vcl_B, "B", vcl_A, true); test_gemm<op_minus_assign>(epsilon, std_B, std_A, std_C, vcl_B, "B", vcl_A, "A", vcl_A, false); test_gemm<op_minus_assign>(epsilon, std_A, std_A, std_C, vcl_A, "A", vcl_A, "A", vcl_A, true); std::cout << std::endl; // // Matrix-Matrix (sparse times dense) // // A = sparse * A viennacl::copy(std_A, vcl_A); for (std::size_t i = 0; i<std_A.size(); ++i) for (std::size_t j = 0; j<std_A[i].size(); ++j) { NumericT tmp = 0; for (std::size_t k = 0; k<std_A[i].size(); ++k) tmp += std_Asparse[i][KeyType(k)] * std_A[k][j]; std_C[i][j] = tmp; } viennacl::copy(std_A, vcl_A); vcl_A = viennacl::linalg::prod(vcl_A_csr, vcl_A); check(std_C, vcl_A, "A = csr*A", epsilon); viennacl::copy(std_A, vcl_A); vcl_A = viennacl::linalg::prod(vcl_A_coo, vcl_A); check(std_C, vcl_A, "A = coo*A", epsilon); viennacl::copy(std_A, vcl_A); vcl_A = viennacl::linalg::prod(vcl_A_ell, vcl_A); check(std_C, vcl_A, "A = ell*A", epsilon); viennacl::copy(std_A, vcl_A); //vcl_A = viennacl::linalg::prod(vcl_A_sell, vcl_A); //check(std_C, vcl_A, "A = sell*A", epsilon); viennacl::copy(std_A, vcl_A); vcl_A = viennacl::linalg::prod(vcl_A_hyb, vcl_A); check(std_C, vcl_A, "A = hyb*A", epsilon); // A = sparse * A^T viennacl::copy(std_A, vcl_A); for (std::size_t i = 0; i<std_A.size(); ++i) for (std::size_t j = 0; j<std_A[i].size(); ++j) { NumericT tmp = 0; for (std::size_t k = 0; k<std_A[i].size(); ++k) tmp += std_Asparse[i][KeyType(k)] * std_A[j][k]; std_C[i][j] = tmp; } viennacl::copy(std_A, vcl_A); vcl_A = viennacl::linalg::prod(vcl_A_csr, trans(vcl_A)); check(std_C, vcl_A, "A = csr*A^T", epsilon); viennacl::copy(std_A, vcl_A); vcl_A = viennacl::linalg::prod(vcl_A_coo, trans(vcl_A)); check(std_C, vcl_A, "A = coo*A^T", epsilon); viennacl::copy(std_A, vcl_A); vcl_A = viennacl::linalg::prod(vcl_A_ell, trans(vcl_A)); check(std_C, vcl_A, "A = ell*A^T", epsilon); viennacl::copy(std_A, vcl_A); //vcl_A = viennacl::linalg::prod(vcl_A_sell, trans(vcl_A)); //check(std_C, vcl_A, "A = sell*A^T", epsilon); viennacl::copy(std_A, vcl_A); vcl_A = viennacl::linalg::prod(vcl_A_hyb, trans(vcl_A)); check(std_C, vcl_A, "A = hyb*A^T", epsilon); return EXIT_SUCCESS; }
int main(int argc, char** argv) { time_state state = START; struct timespec now; int fd; char* sourceaddr; int sourceport; char buf[1024]; char output[1024]; int rc; int signr; struct sigevent sigev; timer_t timer; struct sched_param schedp; sigset_t sigset; uint64_t superframeStartTime; uint64_t timeOffset; uint64_t timeOffsetExtern; int finished; struct itimerspec tspec; unsigned int frameCounter; uint32_t beaconDelay; /* Parse parameters */ if( argc != ARG_COUNT+1 ){ printf("Usage: clocksync <hostname> <portnummer> <adresse> <slotnummer>\n"); exit(1); } char hostname[128]; strncpy(hostname, argv[1], 127); hostname[127] = '\0'; int port = atoi( argv[2] ); char * adresse = argv[3]; int slotnummer = atoi( argv[4] ); uint64_t timeOffsetMidOwnSlot = (20LL /*Beacon-Fenster*/ + 4 /*Sicherheitspause*/ + (slotnummer-1)*4 /*Zeit bis zu eigenem slot*/ + (4/2) /*halbe slotlaenge*/); printf("starting clocksync as: %s, at %s:%d with slotnummer %d\n",hostname,adresse,port,slotnummer); //Initialisiere Socket. //Trete der Multicast-Gruppe bei //Aktiviere Signal SIGIO fd = initSocket( adresse, port ); if( fd < 0 ){ printf("Failed initializing socket at: %s:%d.", adresse, port); exit(1); } //Definiere Ereignis fuer den Timer //Beim Ablaufen des Timers soll das Signal SIGALRM //an die aktuelle Thread gesendet werden. sigev.sigev_notify = SIGEV_THREAD_ID | SIGEV_SIGNAL; sigev.sigev_signo = SIGALRM; sigev.sigev_notify_thread_id = gettid(); //Erzeuge den Timer timer_create(CLOCK, &sigev, &timer); //Umschaltung auf Real-time Scheduler. //Erfordert besondere Privilegien. //Deshalb hier deaktiviert. /* memset(&schedp, 0, sizeof (schedp)); schedp.sched_priority = PRIO; sched_setscheduler(0, POLICY, &schedp); */ //Lege fest, auf welche Signale beim //Aufruf von sigwaitinfo gewartet werden soll. sigemptyset(&sigset); sigaddset(&sigset, SIGIO); //Socket hat Datagramme empfangen sigaddset(&sigset, SIGALRM); //Timer ist abgelaufen sigaddset(&sigset, SIGINT); //Cntrl-C wurde gedrueckt sigprocmask(SIG_BLOCK, &sigset, NULL); //Framecounter initialisieren frameCounter = 0; superframeStartTime = 0; //Differenz zwischen der realen Zeit und der synchronisierten Anwendungszeit. //Die synchronisierte Anwendungszeit ergibt sich aus der Beaconnummer. //Sie wird gerechnet vom Startzeitpunkt des Superframes mit der Beaconnummer 0 timeOffset = 0; timeOffsetExtern = 0; /* wait 3 superframes for beacon from other units !TODO: check!*/ clock_gettime(CLOCK, &now); tspec.it_interval.tv_sec = 0; tspec.it_interval.tv_nsec = 0; nsec2timespec( &tspec.it_value, TIME_START_WAIT_SUPERFRAMES * 100LL /*msec*/ *1000*1000 + timespec2nsec(&now)); timer_settime(timer, TIMER_ABSTIME, &tspec, NULL); printf("Waiting for first beacon.\n"); //Merker fuer Programmende finished = 0; while( finished == 0 ){ //Lese empfangene Datagramme oder warte auf Signale //Diese Abfrage ist ein wenig tricky, da das I/O-Signal (SIGIO) //flankengesteuert arbeitet. signr=0; while( signr == 0 ){ //Pruefe, ob bereits Datagramme eingetroffen sind. //Die muessen erst gelesen werden, da sonst fuer diese kein SIGIO-Signal ausgeloest wird. //Signal wird erst gesendet beim Uebergang von Non-Ready nach Ready (Flankengesteuert!) //Also muss Socket solange ausgelesen werden, bis es Non-Ready ist. //Beachte: Socket wurde auf nonblocking umgeschaltet. //Wenn keine Nachricht vorhanden ist, kehrt Aufruf sofort mit -1 zurueck. errno ist dann EAGAIN. rc = recvMessage( fd, buf, sizeof(buf), &sourceaddr, &sourceport ); if( rc > 0 ){ //Ok, Datagram empfangen. Beende Schleife signr = SIGIO; break; } //Warte auf ein Signal. //Die entsprechenden Signale sind oben konfiguriert worden. siginfo_t info; if (sigwaitinfo(&sigset, &info) < 0){ perror( "sigwait" ); exit(1); } if( info.si_signo == SIGALRM ){ //Timer ist abgelaufen signr = SIGALRM; break; }else if( info.si_signo == SIGINT ){ //Cntrl-C wurde gedrueckt signr = SIGINT; break; } } //So, gueltiges Ereignis empfangen. //Nun geht es ans auswerten. /* Get current time */ clock_gettime(CLOCK, &now); #ifdef DEBUG printf("received signal %d at state %d.\n",signr,state); #endif // DEBUG switch(state){ case START: switch(signr){ case SIGALRM: // no beacon received, I'm first to arrive printf("no beacon arrived within %d superframes, so this must be the first unit.\n",TIME_START_WAIT_SUPERFRAMES); // configure timer for next slottime tspec.it_interval.tv_sec = 0; tspec.it_interval.tv_nsec = 0; superframeStartTime = timespec2nsec(&now); nsec2timespec( &tspec.it_value, superframeStartTime + timeOffsetMidOwnSlot); timer_settime(timer, TIMER_ABSTIME, &tspec, NULL); timeOffset = timespec2nsec(&now); // init offset time state = AWAIT_SLOT_TIME; break; // case SIGALRM case SIGIO: if( buf[0] == 'B' ){ rc = decodeBeacon( buf, &frameCounter, &beaconDelay, NULL, 0); if( rc < 0 ){ printf( "### Invalid Beacon: '%s'\n", buf ); } else { printf("beacon arrived, this is not the first unit.\n"); //Berechne den Zeitpunkt, an dem der Superframe begann superframeStartTime = timespec2nsec( &now ) - beaconDelay; //Starte Zeitmessung mit dem ersten empfangenen Beacon //Differenz zwischen der realen Zeit und der synchronisierten Anwendungszeit. //Die synchronisierte Anwendungszeit ergibt sich aus der Beaconnummer. //Sie wird gerechnet vom Startzeitpunkt des Superframes mit der Beaconnummer 0 timeOffset = superframeStartTime - frameCounter * 100LL /* msec */ * 1000 * 1000; // configure timer for next slottime tspec.it_interval.tv_sec = 0; tspec.it_interval.tv_nsec = 0; nsec2timespec( &tspec.it_value, superframeStartTime + timeOffsetMidOwnSlot); timer_settime(timer, TIMER_ABSTIME, &tspec, NULL); state = AWAIT_SLOT_TIME; } } else { printf("### Received Message is no beacon: '%s'\n", buf ); } break; // case SIGIO case SIGINT: printf("received SIGINT, shutting down.\n"); finished = 1; break; // case SIGINT } // switch signr break; // case START case AWAIT_BEACON: switch(signr){ case SIGALRM: // send beacon, since no beacon arrived before frameCounter++; // send own beacon encodeBeacon(output, sizeof(output), frameCounter, beaconDelay, hostname); sendMessage(fd, output, adresse, port); superframeStartTime = (frameCounter * 100LL /* msec */*1000*1000) + timeOffset; // configure timer for next slottime tspec.it_interval.tv_sec = 0; tspec.it_interval.tv_nsec = 0; nsec2timespec( &tspec.it_value, superframeStartTime + timeOffsetMidOwnSlot); timer_settime(timer, TIMER_ABSTIME, &tspec, NULL); state = AWAIT_SLOT_TIME; break; // case SIGALRM case SIGIO: if( buf[0] == 'B' ){ rc = decodeBeacon( buf, &frameCounter, &beaconDelay, NULL, 0); if( rc < 0 ){ printf( "### Invalid Beacon: '%s'\n", buf ); } else { printf("beacon arrived before sending own beacon.\n"); timeOffsetExtern = timespec2nsec(&now) - (frameCounter * 100LL /* msec */*1000*1000) - beaconDelay; // check, if other starttime is before own calculated offset and adjust offset if needed if(timeOffsetExtern < timeOffset){ timeOffset = timeOffsetExtern; } //Berechne den Zeitpunkt, an dem der Superframe begann superframeStartTime = (frameCounter * 100LL /* msec */*1000*1000) + timeOffset; // configure timer for next slottime tspec.it_interval.tv_sec = 0; tspec.it_interval.tv_nsec = 0; nsec2timespec( &tspec.it_value, superframeStartTime + timeOffsetMidOwnSlot); timer_settime(timer, TIMER_ABSTIME, &tspec, NULL); state = AWAIT_SLOT_TIME; } } else { #ifdef DEBUG printf("### Received Message is no beacon: '%s'\n",buf); #endif // DEBUG } break; // case SIGIO case SIGINT: printf("received SIGINT, shutting down.\n"); finished = 1; break; // case SIGINT } // switch signr break; // case AWAIT_BEACON case AWAIT_SLOT_TIME: switch(signr){ case SIGALRM: // send own datagram encodeSlotMessage(output, sizeof(output), slotnummer, hostname); sendMessage(fd, output, adresse, port); // calculate own random delay for next beacon beaconDelay = randomNumber(20 /*msec*/ *1000*1000); // configure timer for next beacon send time tspec.it_interval.tv_sec = 0; tspec.it_interval.tv_nsec = 0; nsec2timespec( &tspec.it_value, superframeStartTime + 100LL /*msec*/ *1000*1000 + beaconDelay); timer_settime(timer, TIMER_ABSTIME, &tspec, NULL); state = AWAIT_BEACON; break; // case SIGALRM case SIGIO: //TODO: maybe error message? break; // case SIGIO case SIGINT: printf("received SIGINT, shutting down.\n"); finished = 1; break; // case SIGINT } // switch signr break; // case AWAIT_SLOT_TIME } // switch state } // while finished == 0 //////////////////////////////////////////////////// //und aufraeumen timer_delete(timer); /* switch to normal */ schedp.sched_priority = 0; sched_setscheduler(0, SCHED_OTHER, &schedp); return 0; }
void randomTriconnectedGraph(Graph &G, int n, double p1, double p2) { if(n < 4) n = 4; // start with K_4 completeGraph(G,4); // nodes[0],...,nodes[i-1] is array of all nodes Array<node> nodes(n); node v; int i = 0; forall_nodes(v,G) nodes[i++] = v; // Will be used below as array of neighbors of v Array<edge> neighbors(n); // used to mark neighbors // 0 = not marked // 1 = marked left // 2 = marked right // 3 = marked both Array<int> mark(0,n-1,0); for(; i < n; ++i) { // pick a random node v = nodes[randomNumber(0,i-1)]; // create a new node w such that v is split into v and w node w = nodes[i] = G.newNode(); // build array of all neighbors int d = v->degree(); int j = 0; adjEntry adj; forall_adj(adj,v) neighbors[j++] = adj->theEdge(); // mark two distinct neighbors for left for(j = 2; j > 0; ) { int r = randomNumber(0,d-1); if((mark[r] & 1) == 0) { mark[r] |= 1; --j; } } // mark two distinct neighbors for right for(j = 2; j > 0; ) { int r = randomNumber(0,d-1); if((mark[r] & 2) == 0) { mark[r] |= 2; --j; } } for(j = 0; j < d; ++j) { int m = mark[j]; mark[j] = 0; // decide to with which node each neighbor is connected // (possible: v, w, or both) double x = randomDouble(0.0,1.0); switch(m) { case 0: if(x < p1) m = 1; else if(x < p1+p2) m = 2; else m = 3; break; case 1: case 2: if(x >= p1+p2) m = 3; break; } // move edge or create new one if necessary edge e = neighbors[j]; switch(m) { case 2: if(v == e->source()) G.moveSource(e,w); else G.moveTarget(e,w); break; case 3: G.newEdge(w,e->opposite(v)); break; } } G.newEdge(v,w); } }
void populateArray(int *list, int size){ int i = 0; for(i = 0; i < size; i++){ list[i] = randomNumber(); } }
void planarTriconnectedGraph(Graph &G, int n, int m) { if (n < 4) n = 4; if(n % 2) ++n; // need an even number // start with K_4 completeGraph(G,4); planarEmbedPlanarGraph(G); // nodes[0],...,nodes[i-1] is array of all nodes Array<node> nodes(n); node v; int i = 0; forall_nodes(v,G) nodes[i++] = v; // create planar triconnected 3-graph for(; i < n; ) { // pick a random node v = nodes[randomNumber(0,i-1)]; adjEntry adj2 = v->firstAdj(); int r = randomNumber(0,2); switch(r) { case 2: adj2 = adj2->succ(); // fall through to next case case 1: adj2 = adj2->succ(); } adjEntry adj1 = adj2->cyclicSucc(); nodes[i++] = G.splitNode(adj1,adj2); r = randomNumber(0,1); if(r == 0) { adjEntry adj = adj1->twin(); G.newEdge(adj2,adj); nodes[i++] = G.splitNode(adj,adj->cyclicSucc()->cyclicSucc()); } else { adjEntry adj = adj1->cyclicSucc()->twin(); G.newEdge(adj2,adj,ogdf::before); nodes[i++] = G.splitNode(adj->cyclicPred(),adj->cyclicSucc()); } } nodes.init(); Array<edge> edges(m); CombinatorialEmbedding E(G); Array<face> faces(2*n); i = 0; face f; forall_faces(f,E) { if(f->size() >= 4) faces[i++] = f; } while(G.numberOfEdges() < m && i > 0) { int r = randomNumber(0,i-1); f = faces[r]; faces[r] = faces[--i]; int p = randomNumber(0,f->size()-1); int j = 0; adjEntry adj, adj2; for(adj = f->firstAdj(); j < p; adj = adj->faceCycleSucc(), ++j) ; p = randomNumber(2, f->size()-2); for(j = 0, adj2 = adj; j < p; adj2 = adj2->faceCycleSucc(), ++j) ; edge e = E.splitFace(adj,adj2); f = E.rightFace(e->adjSource()); if(f->size() >= 4) faces[i++] = f; f = E.rightFace(e->adjTarget()); if(f->size() >= 4) faces[i++] = f; } }
int main(int argc, char * argv[]) { int test_trials = 10000; if (argc > 1) { test_trials = atoi(argv[1]); if (test_trials < 1) { printf("Usage: cardtest1 <trials>\r\n"); exit(1); } } srand(time(NULL)); //new gameState struct gameState * gs = malloc(sizeof(struct gameState)); struct gameState * stateCopy = malloc(sizeof(struct gameState)); int trial; int returnValue; int numberOfErrors = 0; int playerNum; int emptyHand; int emptyDiscard; int emptyDeck; int emptyThree; //not enough cards? int handPos; int drawCards; printf("Card Test 1\r\n"); printf("Conducting %d random trials.\r\n", test_trials); for (trial = 0; trial < test_trials; trial++) { printf("TRIAL %d\r\n", trial); fuzzState(gs); //semi-randomize inputs (within reason) playerNum = randomNumber(2, MAX_PLAYERS) - 2; emptyDeck = percentChanceIsOne(5); emptyDiscard = percentChanceIsOne(5); emptyHand = percentChanceIsOne(5); emptyThree = percentChanceIsOne(1); if (emptyDeck == 1 || emptyThree == 1) { gs->deckCount[playerNum] = 0; } else { gs->deckCount[playerNum] = randomNumber(1, 300); } if (emptyHand == 1 || emptyThree == 1) { gs->handCount[playerNum] = 1; //leave room for Smithy card } else { gs->handCount[playerNum] = randomNumber(2, 300); } if (emptyDiscard == 1 || emptyThree == 1) { gs->discardCount[playerNum] = 0; } else { gs->discardCount[playerNum] = randomNumber(1, 300); } gs->playedCardCount = randomNumber(0,gs->handCount[playerNum]); /*gs->deckCount[playerNum] = randomNumber(5, 300); gs->discardCount[playerNum] = randomNumber(5, 300); gs->handCount[playerNum] = randomNumber(5, 300); */ //set smithy card handPos = randomNumber(0, gs->handCount[playerNum]-1); gs->hand[playerNum][handPos] = smithy; //create copy for comparison later memcpy(stateCopy, gs, sizeof(struct gameState)); //RUN FUNCTION returnValue = playSmithy(handPos, playerNum, gs); //Check state if (stateCopy->deckCount[playerNum] < 3) { if (gs->discardCount[playerNum] != 1) { printf("discardCount is not as expected. Expected: 1, Actual: %d\r\n", gs->discardCount[playerNum]); numberOfErrors++; } } else { if (gs->discardCount[playerNum] != stateCopy->discardCount[playerNum] + 1) { printf("discardCount is not as expected. Expected: %d, Actual: %d\r\n",stateCopy->discardCount[playerNum] + 1, gs->discardCount[playerNum]); numberOfErrors++; } } //check top of discard for smithy if (gs->discard[playerNum][ gs->discardCount[playerNum] - 1 ] != smithy){ printf("top of discard mismatch. Expected: %d, Actual %d\r\n", smithy, gs->discard[playerNum][ gs->discardCount[playerNum] - 1 ]); numberOfErrors++; } if (stateCopy->discardCount[playerNum] + stateCopy->deckCount[playerNum] >= 3) { drawCards = 3; } else { drawCards = stateCopy->discardCount[playerNum] + stateCopy->deckCount[playerNum]; } //drawCards should be drawCards less pluss smithy if (gs->discardCount[playerNum] + gs->deckCount[playerNum] - drawCards + 1 != stateCopy->discardCount[playerNum] + stateCopy->deckCount[playerNum]) { printf("deck + discard count is not as expected. Expected: %d, Actual: %d\r\n",stateCopy->discardCount[playerNum] + stateCopy->deckCount[playerNum] - drawCards + 1, gs->discardCount[playerNum] + gs->deckCount[playerNum]); numberOfErrors++; } //Hand Should have drawCards extra cards minus smithy if (gs->handCount[playerNum] != stateCopy->handCount[playerNum] + drawCards - 1) { printf("handCount is not as expected. Expected: %d, Actual: %d\r\n",stateCopy->handCount[playerNum] + drawCards - 1, gs->handCount[playerNum]); numberOfErrors++; } } printf("Card Test 1 Complete\r\n"); printf("Number of errors found: %d\r\n", numberOfErrors); free(gs); free(stateCopy); return 0; }
//do nothing for now. void *sendPacket() { printf("Sender started.\n\n"); int i; int numbytes; int curr_pos = 0; //simulating corruption int rand; while(1){ //flag set by receiver to resend packets currently in window. if(resend){ resendPackets(left, right); } //sends anytime something gets pushed onto our buffer if((num_in_buffer - sent_unacked) > 0){ /* * rand < 10, no send. * rand >= 10, gen another rand. If < 5, set corrupt to 1. Else, 0. */ rand = randomNumber(100); printf("RAND # %d\n", rand); /*if(rand < 10) printf("Do not send packet\n"); else{ rand = randomNumber(100); if(rand < 5) printf("Setting corrupt bit\n"); else printf("normal packet\n"); }*/ sleep(1); //delay if(buffer[curr_pos]->seq < 0){ //Wait for done packet. if we hit done, halt and wait. if(outstanding == 0){ //dont send until we have none outstanding. //finish this. if(rand > 10){ rand = randomNumber(100); if(rand < 5) { printf("Setting corrupt bit\n"); buffer[curr_pos]->corrupt = 1; } else { printf("Normal packet\n"); buffer[curr_pos]->corrupt = 0; } if ((numbytes = sendto(sockfd, (void *) buffer[curr_pos], sizeof(struct packet), 0, p->ai_addr, p->ai_addrlen)) == -1) { perror("talker: sendto"); exit(1); } printf("Just sent our death pill with left = %d curr post = %d. Peace.\n\n", left, curr_pos); exit(1); //kill program }else{ printf("Skipping packet\n"); } } }else{ if(rand > 10){ rand = randomNumber(100); if(rand < 5){ printf("Setting corrupt bit\n"); buffer[curr_pos]->corrupt = 1; } else { printf("Normal packet\n"); buffer[curr_pos]->corrupt = 0; } if ((numbytes = sendto(sockfd, (void *) buffer[curr_pos], sizeof(struct packet), 0, p->ai_addr, p->ai_addrlen)) == -1) { perror("talker: sendto"); exit(1); } } else{ printf("Skipping packet\n"); } printf("SENT: %s with seq # %d\n\n", buffer[curr_pos]->data, buffer[curr_pos]->seq); just_sent = TRUE; //this flag will allow receiver to start timer again. curr_pos = ((curr_pos + 1) % BUFF_SIZE); sent_unacked++; //increment sent but unacked outstanding++; //printf("Number unacked %d\n", outstanding); } } } }
int main(int argc, char *argv[]) { /* { fix start } */ ltc_mp = ltm_desc; /* { fix end } */ int sockfd = 0; struct sockaddr_in serv_addr; if(argc != 2) { printf("\n Usage: %s <ip of server> \n",argv[0]); return 1; } if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { printf("\n Error : Could not create socket \n"); return 1; } memset(&serv_addr, '0', sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(5002); if(inet_pton(AF_INET, argv[1], &serv_addr.sin_addr)<=0) { printf("\n inet_pton error occured\n"); return 1; } if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { printf("\n Error : Connect Failed \n"); return 1; } initEncrypt(); ecc_key encryptKey; loadKey(&encryptKey, "bpublic.key"); ecc_key decryptKey; loadKey(&decryptKey, "aprivate.key"); /* { userString start } */ printf("Enter message to send\n"); unsigned char message[256]; fgets((char*)message,256,stdin); /* { userString end } */ /* { sendNonceA start } */ int nonceA = randomNumber(); printf("nonceA = %i\n",nonceA); printf("Encrypting nonceA with bpub\n"); unsigned char nonceA_enc[2048]; unsigned long outLength = 2048; ecc_encrypt((unsigned char*)&nonceA, sizeof(int), nonceA_enc, &outLength,&encryptKey); printf("Sending nonceA\n"); write(sockfd, nonceA_enc, outLength); /* { sendNonceA end } */ /* { resiveSessionKey start } */ unsigned char recvBuff[1024]; unsigned long msgLength; msgLength = recv(sockfd, recvBuff, sizeof(recvBuff),0); struct SessionKey sKey; unsigned long inLength = sizeof(struct SessionKey); ecc_decrypt(recvBuff,msgLength,(unsigned char*)&sKey,&inLength,&decryptKey); printf("Received sKey, nonceA = %i, key = %i\n", sKey.nonceA, sKey.key); /* { resiveSessionKey end } */ /* { resendKey start } */ my_aes_setup(sKey.key); sKey.nonceA ++; printf("Sending nonceA = %i encrypted with AES\n", sKey.nonceA); outLength = 2048; aes_encrypt((unsigned char*)&sKey.nonceA,sizeof(int),nonceA_enc, &outLength); write(sockfd, nonceA_enc, outLength); /* { resendKey end } */ /* { sendMessage start } */ printf("Sending message encrypted with AES\n"); printf("%s", message); outLength = 2048; unsigned char message_enc[2048]; aes_encrypt(message, strlen((char*)message), message_enc, &outLength); write(sockfd, message_enc, outLength); /* { sendMessage end } */ return -1; }
void randomHierarchy(Graph &G, int numberOfNodes,int numberOfEdges, bool planar,bool singleSource,bool longEdges) { G.clear(); node *nnr = new node[3*numberOfNodes]; int *vrt = new int[3*numberOfNodes]; int *fst = new int[numberOfNodes+1]; List<bEdge> startEdges; bEdge actEdge, nextEdge, toDelete; node v; int act, next, n1, n2, idc=0; double x1, x2, r; bool connected; /** Place nodes **/ for(int i = 0; i < numberOfNodes; i++) G.newNode(); int numberOfLayers=0, totNumber=0, realCount=0; fst[0] = 0; forall_nodes(v,G) { if(longEdges&&numberOfLayers) vrt[totNumber++] = 1; nnr[totNumber] = v; vrt[totNumber++] = 0; realCount++; r = double(randomNumber(0,1000)) / 1000.0; if((totNumber == 1 && singleSource) || realCount == numberOfNodes || r*r*numberOfNodes < 1) { if(longEdges && numberOfLayers) vrt[totNumber++] = 1; fst[++numberOfLayers] = totNumber; } } /** Determine allowed neighbours **/ int *leftN = new int[totNumber]; int *rightN = new int[totNumber]; for(int l = 1; l < numberOfLayers; l++) { if(planar) { n1 = fst[l-1]; n2 = fst[l]; leftN[n2] = n1; while(n1 < fst[l] && n2 < fst[l+1]) { r = double(randomNumber(0,1000)) / 1000.0; if(n1 != fst[l]-1 && (n2 == fst[l+1]-1 || r < (double)(fst[l]-fst[l-1])/(double)(fst[l+1]-fst[l-1]))) n1++; else { rightN[n2] = n1; if(++n2 < fst[l+1]) leftN[n2] = n1; } } } else for(n2 = fst[l]; n2 < fst[l+1]; n2++) { leftN [n2] = fst[l-1]; rightN[n2] = fst[l]-1; } } /** Insert edges **/ SList<bEdge> *edgeIn = new SList<bEdge>[totNumber]; SList<bEdge> *edgeOut = new SList<bEdge>[totNumber]; if(numberOfLayers) { x1 = numberOfEdges; x2 = 0; for(n2 = fst[1]; n2 < totNumber; n2++) if(!vrt[n2]) x2 += rightN[n2] - leftN[n2]+1; for(n2 = fst[1]; n2 < totNumber; n2++) if(!vrt[n2]) { connected = !singleSource; for(n1 = leftN[n2]; n1 <= rightN[n2] || !connected; n1++) { r = double(randomNumber(0,1000)) / 1000.0; if(r < x1/x2 || n1 > rightN[n2]) { next = (n1 <= rightN[n2] ? n1 : randomNumber(leftN[n2],rightN[n2])); act = n2; nextEdge = OGDF_NEW BEdge(next,act,idc++); while(vrt[next]) { act = next; next = randomNumber(leftN[act],rightN[act]); edgeOut[act].pushBack(nextEdge); nextEdge = OGDF_NEW BEdge(next,act,idc++); edgeIn[act].pushBack(nextEdge); } startEdges.pushBack(nextEdge); connected = 1; x1 -= 1; } if(n1<=rightN[n2]) x2-=1; } } } delete[] leftN; delete[] rightN; if(planar) for(act = 0; act < totNumber; act++) { CmpTail cmpTail; edgeIn[act].quicksort(cmpTail); CmpHead cmpHead; edgeOut[act].quicksort(cmpHead); } for(act = 0; act < totNumber; act++) { SListIterator<bEdge> it; for(it = edgeIn[act].begin(); it.valid(); ++it) { nextEdge = *it; nextEdge->next = edgeOut[act].popFrontRet(); } } delete[] edgeOut; ListIterator<bEdge> it; for(it = startEdges.begin(); it.valid(); ++it) { actEdge = *it; nextEdge = actEdge; while(vrt[nextEdge->head]) nextEdge = nextEdge->next; G.newEdge(nnr[actEdge->tail], nnr[nextEdge->head]); } /** Clean up **/ for(it = startEdges.begin(); it.valid(); ++it) { nextEdge = *it; toDelete = nextEdge; while(vrt[nextEdge->head]) { nextEdge = nextEdge->next; delete toDelete; toDelete = nextEdge; } delete toDelete; } delete[] edgeIn; delete[] fst; delete[] vrt; delete[] nnr; }
int main(int argc, char * argv[]) { char const * fn = NULL; int64_t fs = -1; static int64_t const maxrelfs = 512*1024*1024; static unsigned int numthreads = 32; static int const runs = 128; int t = 0; int allok = 1; if ( !(1<argc) ) { fprintf(stderr,"usage: %s <filename>\n",argv[0]); return EXIT_FAILURE; } fn = argv[1]; srandom(time(NULL)); if ( (fs=getFileSize(fn)) < 0 ) { int const error = errno; fprintf(stderr,"Failed to obtain file size: %s\n", strerror(error)); return EXIT_FAILURE; } fprintf(stderr,"Size of file is %" PRIu64 "\n", (uint64_t)fs); if ( fs > maxrelfs ) fs = maxrelfs; for ( t = 0; allok && (t < runs); ++t ) { uint64_t low = randomNumber(8) % (fs+1); uint64_t high = randomNumber(8) % (fs+1); int rc = -1; char * mem = 0; uint64_t memsize = 0; char * tmem = 0; FILE * file = NULL; int ok = 1; uint64_t i; if ( low > high ) { uint64_t tlow = low; low = high; high = tlow; } rc = liblustreparallelread_readfilepart(fn,low,high,numthreads,&mem,&memsize); if ( rc < 0 ) { int const error = errno; fprintf(stderr, "liblustreparallelread_readfilepart failed: %s\n", strerror(error)); return EXIT_FAILURE; } tmem = (char *)malloc(high-low); if ( ! tmem ) { int const error = ENOMEM; free(mem); fprintf(stderr, "verification failed: %s\n", strerror(error)); return EXIT_FAILURE; } if ( ! (file=fopen(fn,"rb")) ) { int const error = errno; free(mem); free(tmem); fprintf(stderr, "verification failed: %s\n", strerror(error)); return EXIT_FAILURE; } if ( fseek(file,low,SEEK_SET) == -1 ) { int const error = errno; fclose(file); free(mem); free(tmem); fprintf(stderr, "verification failed: %s\n", strerror(error)); return EXIT_FAILURE; } if ( fread(tmem,high-low,1,file) != 1 ) { int const error = errno; fclose(file); free(mem); free(tmem); fprintf(stderr, "verification failed: %s\n", strerror(error)); return EXIT_FAILURE; } ok = 1; for ( i = 0; ok && i < (high-low); ++i ) ok = ok && (mem[i] == tmem[i]); fprintf(stderr,"low %" PRIu64 " high %" PRIu64 " dif %" PRIu64 " %s\n", low, high, (high-low)/(1024*1024), (ok?"ok":"failed")); allok = allok && ok; fclose(file); free(tmem); free(mem); } if ( allok ) { fprintf(stderr,"ok\n"); return EXIT_SUCCESS; } else { fprintf(stderr,"failed\n"); return EXIT_FAILURE; } }
ValueCell::ValueCell() : CellBase(), my_value(randomNumber(MINVAL, MAXVAL)) { }
void Rts2SchedBag::doNSGAIIStep () { // we hold pointers to both parent and child population used/produced by previous step calculateNSGARanks (); // pick n members as parents of new population Rts2Schedule *new_pop[popSize]; unsigned int n = 0; unsigned int f; unsigned int i; for (f = 0; f < NSGAfronts.size (); f++) { calculateNSGACrowdingDistance (f); if (NSGAfronts[f].size () < (popSize - n)) { // copy schedules.. std::vector <Rts2Schedule *>::iterator iter; for (iter = NSGAfronts[f].begin (); iter != NSGAfronts[f].end(); iter++, n++) new_pop[n] = (*iter); NSGAfronts[f].clear (); } else { // sort based on crowding distance std::sort (NSGAfronts[f].begin (), NSGAfronts[f].end (), crowdingComp ()); // copy missing entries.. std::vector <Rts2Schedule *>::iterator iter = NSGAfronts[f].begin (); for (i = 0; n < popSize; i++, n++) { new_pop[n] = (*iter); iter = NSGAfronts[f].erase (iter); } // delete rest of NSGAfronts.. while (iter != NSGAfronts[f].end ()) { delete (*iter); iter = NSGAfronts[f].erase (iter); } while (f < NSGAfronts.size ()) { iter = NSGAfronts[f].begin (); while (iter != NSGAfronts[f].end ()) { delete (*iter); iter = NSGAfronts[f].erase (iter); } f++; } } } // erase current population - its pointer are either in new_pop or deleted.. clear (); reserve (popSize * 2); // put to bag remaining schedules.. for (i = 0; i < popSize; i++) push_back (new_pop[i]); // now new_pop holds members of new population ready for binary tournament.. // we need to calculate indices of population for tournament unsigned int a1[popSize], a2[popSize]; for (i = 0; i < popSize; i++) a1[i] = a2[i] = i; for (i = 0; i < popSize; i++) { unsigned int rand = randomNumber (i, popSize - 1); unsigned int temp = a1[rand]; a1[rand] = a1[i]; a1[i] = temp; rand = randomNumber (i, popSize - 1); temp = a2[rand]; a2[rand] = a2[i]; a2[i] = temp; } // do tournament for (i = 0; i < popSize; i+=4) { Rts2Schedule *parent1 = tournamentNSGA (new_pop[a1[i]], new_pop[a1[i+1]]); Rts2Schedule *parent2 = tournamentNSGA (new_pop[a1[i+2]], new_pop[a1[i+3]]); cross (parent1, parent2); parent1 = tournamentNSGA (new_pop[a2[i]], new_pop[a2[i+1]]); parent2 = tournamentNSGA (new_pop[a2[i+2]], new_pop[a2[i+3]]); cross (parent1, parent2); } for (int m = 0; m < mutationNum; m++) { mutate ((*this)[randomNumber (popSize, popSize * 2 - 1)]); } }
GoldCell::GoldCell() : ValueCell(), my_bonus(randomNumber(MINVALB, MAXVALB)) { }
int Random::getRandomNumber(int min, int max) { std::uniform_int_distribution<int> randomNumber{ min, max }; return randomNumber(dre); }