void ParticleWorld::updateParticles(double deltaTime) { for(int i = 0; i < particleList.size(); i++) { double x = particleList[i].box.x; double y = particleList[i].box.y; double w = particleList[i].box.w; double h = particleList[i].box.h; double jitter = 20.0; double cx = x+w/2.0; double cy = y+h/2.0; w = clamp(w+drand(-jitter, jitter), (double)minBoxSize, (double)width ); h = clamp(h+drand(-jitter, jitter), (double)minBoxSize, (double)height); cx = clamp(cx+drand(-jitter, jitter), w/2.0+1, ((double)width )-w/2.0-1); cy = clamp(cy+drand(-jitter, jitter), h/2.0+1, ((double)height)-h/2.0-1); particleList[i].box.x = cx-w/2.0; particleList[i].box.y = cy-h/2.0; particleList[i].box.w = w; particleList[i].box.h = h; if(particleList[i].box.x < 0) { std::cout << "WTF1" << std::endl; } if(particleList[i].box.y < 0) { std::cout << "WTF2" << std::endl; } if(particleList[i].box.x+particleList[i].box.w >= width) { std::cout << "WTF3" << std::endl; } if(particleList[i].box.y+particleList[i].box.h >= height) { std::cout << "WTF4" << std::endl; } } }
int main(int argc, char **argv) { int numBodies = 1000; bool checkErrors = true; // Parse custom command line args for (int i = 1; i < argc; ++i) { if (strcmp(argv[i],"-N") == 0) { i++; numBodies = atoi(argv[i]); } else if (strcmp(argv[i],"-nocheck") == 0) { checkErrors = false; } } // Init the FMM Kernel and options FMMOptions opts = get_options(argc, argv); typedef UnitKernel kernel_type; kernel_type K; typedef kernel_type::point_type point_type; typedef kernel_type::source_type source_type; typedef kernel_type::target_type target_type; typedef kernel_type::charge_type charge_type; typedef kernel_type::result_type result_type; // Init points and charges std::vector<source_type> points(numBodies); for (int k = 0; k < numBodies; ++k) points[k] = source_type(drand(), drand(), drand()); std::vector<charge_type> charges(numBodies); for (int k = 0; k < numBodies; ++k) charges[k] = drand(); // Build the FMM //fmm_plan plan = fmm_plan(K, bodies, opts); FMM_plan<kernel_type> plan = FMM_plan<kernel_type>(K, points, opts); // Execute the FMM //fmm_execute(plan, charges, target_points); std::vector<result_type> result = plan.execute(charges); // Check the result if (checkErrors) { std::vector<result_type> exact(numBodies); // Compute the result with a direct matrix-vector multiplication Direct::matvec(K, points, charges, exact); int wrong_results = 0; for (unsigned k = 0; k < result.size(); ++k) { printf("[%03d] exact: %lg, FMM: %lg\n", k, exact[k], result[k]); if ((exact[k] - result[k]) / exact[k] > 1e-13) ++wrong_results; } printf("Wrong counts: %d\n", wrong_results); } }
// plays event group extinction and group replication void event_group_ext_rep() { int j, g, gr; double m, t; m = pi_g[0]; t = -m; // set distribution probability for(j = G; j--; ){ Gr_dist->p[j] = pi_g[j]; // probabilith of recolonisation of group proportional to +ve of group payoff Ge_dist->p[j] = -pi_g[j]; // probability of extinction of group proporttional to -ve of group payoff if(m < Gr_dist->p[j]) m = Gr_dist->p[j]; if(t < Ge_dist->p[j]) t = Ge_dist->p[j]; } exp_initdist(Gr_dist, 0); exp_initdist(Ge_dist, 0); g = drand(Ge_dist); // select group to extinction gr = drand(Gr_dist); // select group to repopulate if( g == gr) return; // if same, then noop // make selected group extinct and repopulate by another for(j = N; j--;){ // copy strategies from repopulating group individuals to extincting individuals x[g][j] = x[gr][j]; // replace strategy dxi[g][j] = dxi[gr][j]; //replace threshold dsi[g][j] = dsi[gr][j]; // replace aggressiveness pi[g][j] = pi[gr][j]; // replace payoff Api[g][j] = Api[gr][j]; } pi_g[g] = pi_g[gr]; // replace group payoff }
void TcpSrcPeriodic::doNextEvent() { if (_idle_time==0||_active_time==0) { _is_active = true; startflow(); return; } if (_is_active) { if (eventlist().now()>=_end_active && _idle_time!=0 && _active_time!=0 ) { _is_active = false; //this clears RTOs too reset(); eventlist().sourceIsPendingRel(*this,(simtime_picosec)(2*drand()*_idle_time)); } else if (_rtx_timeout_pending) { TcpSrc::doNextEvent(); } else { cout << "Wrong place to be in: doNextDEvent 1" << eventlist().now() << " end active " << _end_active << "timeout " << _rtx_timeout_pending << endl; //maybe i got a timeout here. How? exit(1); } } else { _is_active = true; ((TcpSinkPeriodic*)_sink)->reset(); _start_active = eventlist().now(); _end_active = _start_active + (simtime_picosec)(2*drand()*_active_time); eventlist().sourceIsPending(*this,_end_active); startflow(); } }
int main(int argc, char** argv) { if (argc < 2) { std::cerr << "Usage: test_tree NUM_POINTS\n"; exit(1); } int N = atoi(argv[1]); typedef Vec<3,double[3]> point_type; Octree<point_type> otree(BoundingBox<point_type>(point_type(0), point_type(1))); std::vector<point_type> points; for (int k = 0; k < N; ++k) { point_type p; p[0] = drand(); p[1] = drand(); p[2] = drand(); points.push_back(p); } otree.construct_tree(points.begin(), points.end()); std::cout << otree << "\n"; return 0; }
static int artefact_loose_to_cave (db_t *database, struct Cave *cave) { db_result_t *result; dstring_t *query; int x, y; int minX, minY, maxX, maxY, rangeX, rangeY; /* number between -ALR <= n <= ALR */ x = (int) ((ARTEFACT_LOST_RANGE * 2 + 1) * drand()) - ARTEFACT_LOST_RANGE; y = (int) ((ARTEFACT_LOST_RANGE * 2 + 1) * drand()) - ARTEFACT_LOST_RANGE; x += cave->xpos; y += cave->ypos; /* these numbers may be out of range */ if (! map_get_bounds(database, &minX, &maxX, &minY, &maxY)) { return 0; } rangeX = maxX - minX +1; rangeY = maxY - minY +1; x = ( (x-minX+rangeX) % (rangeX) ) + minX; y = ( (y-minY+rangeY) % (rangeY) ) + minY; query = dstring_new("SELECT caveID FROM " DB_TABLE_CAVE " WHERE xCoord = %d AND yCoord = %d", x, y); debug(DEBUG_SQL, "%s", dstring_str(query)); result = db_query_dstring(database, query); return db_result_next_row(result) ? db_result_get_int(result, "caveID") : 0; }
int main(void) { for (int i = 0; i < num; ++i) { bool neg = rand() < mid; bool zrw = rand() < mid; //bool zrn = rand() < mid; if (neg) { if (zrw) { std::cout << "0 -" << rand() << "/" << drand() << std::endl; } //else if (zrn) { // std::cout << "-" << rand() << " 0/" << drand() << std::endl; //} else { std::cout << "-" << rand() << " " << rand() << "/" << drand() << std::endl; } } else { if (zrw) { std::cout << "0 " << rand() << "/" << drand() << std::endl; } //else if (zrn) { // std::cout << rand() << " 0/" << drand() << std::endl; //} else { std::cout << rand() << " " << rand() << "/" << drand() << std::endl; } } } return 0; }
void ParticleWorld::breedParticles() { std::vector<Particle> newParticleList; double scoreSum = 0.0; for(int i = 0; i < particleList.size(); i++) { scoreSum += particleList[i].score; } int desiredParticleCount = particleList.size(); for(int newParticleI = 0; newParticleI < desiredParticleCount; newParticleI++) { Particle newParticle; //double createNewScore = 1-scoreSum; //std::cout << scoreSum << "; " << createNewScore << std::endl; //double selection = drand(0, scoreSum+createNewScore); //if(selection > scoreSum) { // setRandParticle(newParticle); //} else { if(drand(0.0, 1.0) < 0.03) { setRandParticle(newParticle); } else { double selection = drand(0, scoreSum); double total = 0; for(int oldParticleI = 0; oldParticleI < particleList.size(); oldParticleI++){ total += particleList[oldParticleI].score; if (total > selection) { newParticle = particleList[oldParticleI]; break; } } } newParticleList.push_back(newParticle); } particleList = newParticleList; }
void uniform_stress(int dim, SparseMatrix A, real *x, int *flag){ UniformStressSmoother sm; real lambda0 = 10.1, M = 100, scaling = 1.; real res; int maxit = 300, samepoint = TRUE, i, k, n = A->m; SparseMatrix B = NULL; *flag = 0; /* just set random initial for now */ for (i = 0; i < dim*n; i++) { x[i] = M*drand(); } /* make sure x is not all at the same point */ for (i = 1; i < n; i++){ for (k = 0; k < dim; k++) { if (ABS(x[0*dim+k] - x[i*dim+k]) > MACHINEACC){ samepoint = FALSE; i = n; break; } } } if (samepoint){ srand(1); #ifdef DEBUG_PRINT fprintf(stderr,"input coordinates to uniform_stress are the same, use random coordinates as initial input"); #endif for (i = 0; i < dim*n; i++) x[i] = M*drand(); } B = get_distance_matrix(A, scaling); assert(SparseMatrix_is_symmetric(B, FALSE)); sm = UniformStressSmoother_new(dim, B, x, 1000000*lambda0, M, flag); res = UniformStressSmoother_smooth(sm, dim, x, maxit); UniformStressSmoother_delete(sm); sm = UniformStressSmoother_new(dim, B, x, 10000*lambda0, M, flag); res = UniformStressSmoother_smooth(sm, dim, x, maxit); UniformStressSmoother_delete(sm); sm = UniformStressSmoother_new(dim, B, x, 100*lambda0, M, flag); res = UniformStressSmoother_smooth(sm, dim, x, maxit); UniformStressSmoother_delete(sm); sm = UniformStressSmoother_new(dim, B, x, lambda0, M, flag); res = UniformStressSmoother_smooth(sm, dim, x, maxit); UniformStressSmoother_delete(sm); scale_to_box(0,0,7*70,10*70,A->m,dim,x);; SparseMatrix_delete(B); }
static inline void random_move (gint *x, gint *y, gint max) { gdouble angle = drand () * G_PI; gdouble radius = drand () * (gdouble) max; *x = (gint) (radius * cos (angle)); *y = (gint) (radius * sin (angle)); }
GLvoid InitGL(GLvoid) { int i; glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // This Will Clear The Background Color To Black glClearDepth(1.0); // Enables Clearing Of The Depth Buffer glDepthFunc(GL_LESS); // The Type Of Depth Test To Do glEnable(GL_DEPTH_TEST); // Enables Depth Testing glShadeModel(GL_SMOOTH); // Enables Smooth Color Shading glMatrixMode(GL_PROJECTION); glLoadIdentity(); // Reset The Projection Matrix gluPerspective(45.0f, (GLfloat)kWindowWidth/(GLfloat)kWindowHeight,0.1f,100.0f); // Calculate The Aspect Ratio Of The Window glMatrixMode(GL_MODELVIEW); for (i=0; i<N; i++) { mr[i].r = rect_open(); rect_init(mr[i].r, RECT5whxyz ,drand()/5.0+0.1,drand()/5.0+0.1, drand(),drand(),drand()); rect_setcolor(mr[i].r, drand(), drand(), drand()); mr[i].dx=drand()/10; mr[i].dy=mr[i].dx; } /*for*/ }
int main() { typedef LaplaceSpherical kernel_type; kernel_type K(5); typedef kernel_type::point_type point_type; typedef kernel_type::charge_type charge_type; typedef kernel_type::result_type result_type; FMMOptions opts; opts.set_mac_theta(.5); opts.set_max_per_box(125); // optimal ncrit std::vector<std::pair<unsigned,double>> times; double tic, toc; int numBodies = 1000000; // initialize points std::vector<point_type> points(numBodies); for (int k=0; k<numBodies; ++k){ points[k] = point_type(drand(), drand(), drand()); } // initialize charges std::vector<charge_type> charges(numBodies); for (int k=0; k<numBodies; ++k){ charges[k] = drand(); } // loop in ncrit for (int ncrit=50; ncrit<=400; ncrit+=50){ opts.set_max_per_box(ncrit); // create FMM plan FMM_plan<kernel_type> plan = FMM_plan<kernel_type>(K, points, opts); // execute FMM // run 3 times and make an average int nt = 3; // number of identical runs for timing std::vector<double> timings(nt); std::vector<result_type> result(numBodies); for (int i=0; i<nt; i++){ tic = get_time(); result = plan.execute(charges); toc = get_time(); timings[i] = toc-tic; } double FMM_time = std::accumulate(timings.begin(), timings.end(), 0.0) / timings.size(); std::cout << ncrit << " " << FMM_time << std::endl; } return 0; }
int fill8bitData(void) { int len, i; len = 1 + (int)drand((MAX_LENGTH - 2)); for(i=0; i<len; i++) { data[i] = (unsigned char)drand(256); } data[len] = '\0'; return len; }
int fillANData(void) { int len, i; len = 1 + (int)drand((MAX_LENGTH - 2)); for(i=0; i<len; i++) { data[i] = AN[(int)drand(45)]; } data[len] = '\0'; return len; }
Compute::Compute(void) { current_time = GetTickCount(); double speed = 0.25*GetSystemMetrics(SM_CXSCREEN); double angle = 8.0*std::atan(1.0)*drand(); velocity_x = speed*std::cos(angle); velocity_y = speed*std::sin(angle); int screen_width = GetSystemMetrics(SM_CXSCREEN); int screen_height = GetSystemMetrics(SM_CYSCREEN); position_x = screen_width*drand(); position_y =screen_height*drand(); offset = int(std::sqrt(0.01*screen_width*screen_height)); }
// Box-Muller optimized static double gaussRandom() { double u,v,r,c; u = 2.0*drand()-1; v = 2.0*drand()-1; r = u*u + v*v; if (r == 0.0 || r > 1.0) return gaussRandom(); c = sqrtl(-2*logl(r)/logl(M_E)/r); return u*c; }
/* Fullscreen antialiasing. Ultra-slow. */ Ray camera_ray_aa(Camera *cam, int i, int j, int sample, double near) { float offx, offy; int p, q; const float n = (float) config->aa_samples; p = sample % config->aa_samples; q = sample / config->aa_samples; offx = (p + drand()) / n; offy = (q + drand()) / n; return cam_ray_internal(cam, i, j, offx, offy, near); }
int main(int argc, char* argv){ uint64_t seed; Compl z, c, tmp; int i, j; int N1, N0; double etime0, etime1, cptime; double A; double r; int n; // boundary lowerLeft.real = -2.0; lowerLeft.imag = 0; upperRight.real = 0.5; upperRight.imag = 1.125; omp_set_dynamic(0); #pragma omp parallel dsrand(12345); N1 = N0 = 0; timing(&etime0, &cptime); #pragma omp parallel firstprivate(j, n, c, z, tmp, stride) \ shared(i, N0, N1, lowerLeft, upperRight, threshold, MAX_ITERATE) #pragma omp for schedule(static, 10) collapse(2) for(i = 0; i < (int)((upperRight.real - lowerLeft.real) / stride); i++){ for(j = 0; j < (int)((upperRight.imag - lowerLeft.imag) / stride); j++){ if(i == 0 && j == 0 && omp_get_thread_num() == 0) printf("Threads: %d\n", omp_get_num_threads()); c.real = lowerLeft.real + (drand() + i) * stride; c.imag = lowerLeft.imag + (drand() + j) * stride; z = c; for(n = 0; n < MAX_ITERATE; n++){ multiply(&z, &c, &tmp); z = tmp; if(lengthsq(&z) > threshold * threshold){ break; } } if(n == MAX_ITERATE){ #pragma omp critical(N1) N1++; }else{ #pragma omp critical(N0) N0++; } } } timing(&etime1, &cptime); A = 2.0 * N1 / (N0 + N1) * (upperRight.real - lowerLeft.real) * (upperRight.imag - lowerLeft.imag); printf("area is %f, time elapsed is %f, total cell: %d\n", A, etime1 - etime0, N1 + N0); }
int mutation(individual *ind) { int i; if (ind == NULL) { return (1); } for (i = 0; i < ind->n; i++) { if (drand(1) <= variable_mutation_probability) { double eta = eta_mutation; double u = drand(1.0); double delta = 0; double x = ind->x[i]; double lb = 0; /* lower bound of variable i */ double ub = 1; /* upper bound of variable i */ double diff = ub - lb; /* range of variable i */ double maxmut0 = x - lb; double maxmut = ub - x; double delta_max = maxmut0 / diff; if (maxmut0 > maxmut) { delta_max = maxmut / diff; } if (u < 0.5) { double b = 2*u + (1-2*u)*(pow(1-delta_max,(eta+1))); delta = pow(b,(1.0/(eta+1))) - 1.0; } else { double b = 2*(1-u) + 2*(u-0.5)*(pow(1-delta_max,(eta+1))); delta = 1.0 - pow(b,(1.0/(eta+1))); } if (delta > delta_max) /* machine accuracy problem */ delta = delta_max; else if (delta < -delta_max) delta = -delta_max; ind->x[i] = x + delta * diff; } } return (0); }
void CStaticStructure::ProcessFrame(unsigned int dwCurrentTime,double dTimeFraction) { CEntityBase::ProcessFrame(dwCurrentTime,dTimeFraction); m_dwNextProcessFrame=dwCurrentTime+10; if(GetState()==eStaticStructureState_Destroyed){return;} if(GetState()==eStaticStructureState_Normal) { size_t nAnimationToSet=0; double dMaxHealth=GetMaxHealth(); unsigned int nAnimations=m_pTypeBase->GetStateAnimations(ENTITY_STATE_BASE); nAnimationToSet=(size_t)(((dMaxHealth-m_dHealth)/dMaxHealth)*((double)nAnimations)); if(nAnimationToSet>nAnimations-1){nAnimationToSet=nAnimations-1;} SetState(ENTITY_STATE_BASE,(int)nAnimationToSet); } bool bAllChildDead=true; for(unsigned int x=0;x<m_vChildren.size();x++){if(m_vChildren[x].piEntity->GetHealth()>0){bAllChildDead=false;}} m_dwDamageType=(bAllChildDead?m_nConfiguredDamageType:DAMAGE_TYPE_NONE); if(m_dwAlignment==ENTITY_ALIGNMENT_ENEMIES) { GetTarget(); } if(m_piTarget && dwCurrentTime>m_dwNextShotTime && m_vWeapons.size()) { bool bVisible=g_PlayAreaManagerWrapper.m_piInterface && g_PlayAreaManagerWrapper.m_piInterface->IsVisible(m_PhysicInfo.vPosition,0); if(bVisible) { double dDifficulty=g_PlayerManagerWrapper.m_piInterface->GetEffectiveDifficulty(); double dTimeFirstShotMin=m_pType->m_dTimeFirstShotMin/dDifficulty; double dTimeFirstShotMax=m_pType->m_dTimeFirstShotMax/dDifficulty; double dTimeBetweenShotsMin=m_pType->m_dTimeBetweenShotsMin/dDifficulty; double dTimeBetweenShotsMax=m_pType->m_dTimeBetweenShotsMax/dDifficulty; if(m_bFirstTimeVisible) { m_bFirstTimeVisible=false; m_dwNextShotTime=dwCurrentTime+drand()*(dTimeFirstShotMax-dTimeFirstShotMin)+dTimeFirstShotMin; } else { for(unsigned int x=0;x<m_vWeapons.size();x++){FireWeapon(x,dwCurrentTime);} m_dwNextShotTime=dwCurrentTime+drand()*(dTimeBetweenShotsMax-dTimeBetweenShotsMin)+dTimeBetweenShotsMin; } } } }
void DiamondSquare::square(int x, int y, PassSettings *settings) { int points = 0; double total = 0.0; int dif = settings->passSize / 2; // Left if (isValid(x - dif, y, settings->mapSize)) { points++; total += (settings->map)[(y) * settings->mapSize + (x - dif)]; } // Top if (isValid(x, y - dif, settings->mapSize)) { points++; total += (settings->map)[(y - dif) * settings->mapSize + (x)]; } // Right if (isValid(x + dif, y, settings->mapSize)) { points++; total += (settings->map)[(y) * settings->mapSize + (x + dif)]; } // Bottom if (isValid(x, y + dif, settings->mapSize)) { points++; total += (settings->map)[(y + dif) * settings->mapSize + (x)]; } total /= (double) points; total += drand() * settings->displacementModifier; (settings->map)[y * settings->mapSize + x] = total; }
// Delete the file located at path. // If "retry" is set, do retries for 5 sec in case some // other program (e.g. virus checker) has the file locked. // Don't do this if deleting directories - it can lock up the Manager. // int delete_project_owned_file(const char* path, bool retry) { int retval = 0; retval = delete_project_owned_file_aux(path); if (retval && retry) { if (log_flags.slot_debug) { msg_printf(0, MSG_INFO, "[slot] delete of %s failed (%d); retrying", path, retval ); } double start = dtime(); do { boinc_sleep(drand()*2); // avoid lockstep retval = delete_project_owned_file_aux(path); if (!retval) break; } while (dtime() < start + FILE_RETRY_INTERVAL); } if (retval) { if (log_flags.slot_debug) { msg_printf(0, MSG_INFO, "[slot] failed to remove file %s: %s", path, boincerror(retval) ); } safe_strcpy(boinc_failed_file, path); return ERR_UNLINK; } if (log_flags.slot_debug) { msg_printf(0, MSG_INFO, "[slot] removed file %s", path); } return 0; }
void test_decodeVeryLong(void) { char str[4000]; int i; QRcode *qrcode; QRdata *qrdata; testStart("Test code words (very long string)."); for(i=0; i<3999; i++) { str[i] = decodeAnTable[(int)drand(45)]; } str[3999] = '\0'; qrcode = QRcode_encodeString(str, 0, QR_ECLEVEL_L, QR_MODE_8, 0); qrdata = QRcode_decode(qrcode); assert_nonnull(qrdata, "Failed to decode.\n"); if(qrdata != NULL) { assert_equal(strlen(str), qrdata->size, "Lengths of input/output mismatched.\n"); assert_zero(strncmp(str, (char *)(qrdata->data), qrdata->size), "Decoded data %s is different from the original %s\n", qrdata->data, str); } if(qrdata != NULL) QRdata_free(qrdata); if(qrcode != NULL) QRcode_free(qrcode); testFinish(); }
void create_pipe(){ static const double h_min=(DISPLAY_HEIGHT-barrier_height_range)/2.0f; static const double h_max=(DISPLAY_HEIGHT-(DISPLAY_HEIGHT-barrier_height_range)/2.0f)-barrier_gap; double height=drand(h_min,h_max); // init upper pipe pipes.push_back(new my_pipe); pipes.back()->set_values(my_pipe::pipe_image,40+DISPLAY_WIDTH,al_get_bitmap_height(my_pipe::pipe_image)/2-height-barrier_gap,-(DISPLAY_WIDTH/barrier_lifetime),0); pipes.back()->has_passed=0; pipes.back()->is_pair_leader=1; // init lower pipe pipes.push_back(new my_pipe); pipes.back()->set_values(my_pipe::pipe_image,40+DISPLAY_WIDTH,al_get_bitmap_height(my_pipe::pipe_image)/2+DISPLAY_HEIGHT-height,-(DISPLAY_WIDTH/barrier_lifetime),0); pipes.back()->has_passed=0; pipes.back()->is_pair_leader=0; menu->to_top(); start_button->to_top(); quit_button->to_top(); score_string->to_top(); #ifdef NDEBUG tick_string->to_top(); vel_string->to_top(); #endif bird->to_top(); }
Lit Solver::pickBranchLit(int polarity_mode, double random_var_freq) { Var next = var_Undef; // Random decision: if (drand(random_seed) < random_var_freq && !order_heap.empty()){ next = order_heap[irand(random_seed,order_heap.size())]; if (toLbool(assigns[next]) == l_Undef && decision_var[next]) rnd_decisions++; } // Activity based decision: while (next == var_Undef || toLbool(assigns[next]) != l_Undef || !decision_var[next]) if (order_heap.empty()){ next = var_Undef; break; }else next = order_heap.removeMin(); bool sign = false; switch (polarity_mode){ case polarity_true: sign = false; break; case polarity_false: sign = true; break; case polarity_user: sign = polarity[next]; break; case polarity_rnd: sign = irand(random_seed, 2); break; default: assert(false); } return next == var_Undef ? lit_Undef : Lit(next, sign); }
bool test(double probability) { return (drand()<probability); /* // C++11 version: std::bernoulli_distribution distribution(probability); return distribution(generator); */ }
// generate random verctor with normal distribution void MainWindow::generate_normal_vector(double * vec) { if (!vec) return; for (int i = 0; i < m; ++i) vec[i] = drand(); }
void vpRagdollWorld::UserInputFun(unsigned char dir) { static int sidx = 0; static int jidx = 0; static int kidx = 0; switch ( dir ) { case 0x26 : // up SetGravity(Vec3(0.0, 10.0, 0.0)); break; case 0x28: // down SetGravity(Vec3(0.0, -10.0, 0.0)); break; case 0x25: // left SetGravity(Vec3(-10.0, 0.0, 0.0)); break; case 0x27: // right //SetGravity(Vec3(10.0, 0.0, 0.0)); break; case 0x24: // home SetGravity(Vec3(0.0, 0.0, 10.0)); break; case 0x23: //end SetGravity(Vec3(0.0, 0.0, -10.0)); break; case 0x20: // space sidx++; sidx %= NUM_STONE; stone[sidx].SetFrame(Vec3(drand(-6.0 * NUM_PUPPET, 6.0 * NUM_PUPPET), -30.0, drand(10.0, 20.0))); stone[sidx].SetGenVelocity(se3(0, 0, 0, 0, 20, 0)); break; case 'b': puppet[jidx][kidx].J_rope[NUM_ROPE].Break(); kidx++; if ( kidx == NUM_PUPPET ) { jidx++; if ( jidx == NUM_PUPPET ) jidx = 0; kidx = 0; } break; } }
static void get_vtx(struct asteroid *a, float r) { float theta = 360.0 / NUM_VTX; for (int i = 0; i < NUM_VTX;) { float x_var = arand() * MAX_VARIANCE * r; float y_var = arand() * MAX_VARIANCE * r; int deviation_size = NUM_VTX / 2 + rand() % (NUM_VTX / 2); deviation_size /= asteroid_smoothness; for (int j = 0; j < deviation_size && i < NUM_VTX; j++, i++) { x_var += drand() * MAX_INTM_VARIANCE * r; y_var += drand() * MAX_INTM_VARIANCE * r; float x = cos(deg_to_radf(theta * i)) * r + x_var; float y = sin(deg_to_radf(theta * i)) * r + y_var; a->vtx[i].x = x; a->vtx[i].y = y; } } }
int random_level(int MAX_LEVEL, double P) { static bool first = true; if (first) { srand( (unsigned)time( NULL ) ); first = false; } int lvl = (int)(std::log(drand())/std::log(1.0-P)); return lvl < MAX_LEVEL ? lvl : MAX_LEVEL; }