void wasmint::TestCaseGenerator::mutateSource() { if (finalSource_.empty()) return; std::size_t start = randomInRange(finalSource_.size()); std::size_t length = randomInRange(finalSource_.size()); finalSource_.erase(start, length); }
/* 快速排序 分类函数 */ int partition(int data[], int length, int start, int end) { if (data == NULL || length <= 0 || start < 0 || end >= length) { throw new std::exception("Invalid parameters"); } int index = randomInRange(start, end); Swap(&data[index], &data[end]); // 只是在第一步随机交换一下,即改变了取最后一个值,处理已排序序列的尴尬! int small = start - 1; for (index = start; index < end; index++) { if (data[index] < data[end]) { small++; if (small != index) { // 把前面大的,和后面小的交换!小的再后面才发现,small就是小的一边的边界! 非常巧妙 Swap(&data[index], &data[small]); } } } small; Swap(&data[small], &data[end]); return small; }
int partition(int *data,int length,int start,int end) { if(data==NULL || start<0 || length<0 || end>=length) return -1; int index=randomInRange(start,end); int temp; temp=data[end]; data[end]=data[index]; data[index]=temp; int small=start-1; int i=start; for(;i<end;i++){ if(data[i]<data[end]){ small++; if(i>small){ temp=data[i]; data[i]=data[small]; data[small]=temp; } } } temp=data[end]; data[end]=data[small+1]; data[small+1]=temp; return (small+1); }
/* ********************************************************************************************* */ VectorXd RRT::getRandomConfig() { // Samples a random point for qtmp in the configuration space, bounded by the provided // configuration vectors (and returns ref to it) VectorXd config(ndim); for (int i = 0; i < ndim; ++i) { config[i] = randomInRange(robot->getGenCoord(dofs[i])->getConfigMin(), robot->getGenCoord(dofs[i])->getConfigMax()); } return config; }
/* ********************************************************************************************* */ VectorXd RRT::getRandomConfig() { // Samples a random point for qtmp in the configuration space, bounded by the provided // configuration vectors (and returns ref to it) VectorXd config(ndim); for (int i = 0; i < ndim; ++i) { config[i] = randomInRange(robot->getPositionLowerLimit(dofs[i]), robot->getPositionUpperLimit(dofs[i])); } return config; }
/** * @function getRandomConfig * @brief Samples a random point for qtmp in the configuration space, * bounded by the provided configuration vectors (and returns ref to it) */ Eigen::VectorXd B1RRT::getRandomConfig() { Eigen::VectorXd config( ndim ); for( unsigned int i = 0; i < ndim; i++ ) { double minVal = world->mRobots[robotId]->getDof(links[i])->getMin(); double maxVal = world->mRobots[robotId]->getDof(links[i])->getMax(); config[i] = randomInRange( minVal, maxVal ); } return config; }
// ------------------------------------- // Main function // ------------------------------------- void appMain(void) { uint16_t i; // timers (used to get an extra interrupt context) alarmInit(&timer, onTimer, NULL); alarmSchedule(&timer, 1000); // radio radioSetReceiveHandle(radioRecvCb); radioOn(); for (i = 0; i < BUFFER_SIZE; i++) { buffer[i] = i; } randomInit(); // SELECT_FLASH; // extFlashBulkErase(); // UNSELECT_FLASH; for (i = 0; ; i++) { uint32_t address = i * 64ul; SELECT_FLASH; if (IS_ALIGNED(address, EXT_FLASH_SECTOR_SIZE)) { PRINTF("erase address %lu\n", address); flashErase(address); } PRINTF("write address %lu\n", address); flashWrite(address); if (address > 0) { PRINTF("verify...\n"); flashRead(address - 64); } UNSELECT_FLASH; msleep(randomInRange(400, 1000)); PRINTF("send smth to radio...\n"); radioSend("hello world", sizeof("hello world")); greenLedToggle(); } }
static uint32_t calcNextForwardTime(uint8_t moteToProcess) { uint16_t rnd = randomInRange(200, 400); if (moteToProcess == 0) { return timeToNextFrame() + 4000 + rnd + (IS_ODD_COLLECTOR ? MAX_MOTES * MOTE_TIME_FULL : 0); } uint32_t passedTime = timeSinceFrameStart(); uint32_t requiredTime = 4000ul + (IS_ODD_COLLECTOR ? MAX_MOTES * MOTE_TIME_FULL : 0) + MOTE_TIME_FULL * moteToProcess + rnd; if (passedTime >= requiredTime) return 0; return requiredTime - passedTime; }
static void TestMonkey(void) { int32_t scale; UErrorCode status = U_ZERO_ERROR; for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { int64_t fromMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MIN_VALUE, &status); int64_t fromMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MAX_VALUE, &status); int32_t i; initRandom(fromMin, fromMax); for (i = 0; i < LOOP_COUNT; i += 1) { int64_t value = randomInRange(); roundTripTest(value, (UDateTimeScale)scale); } } }
void routingInit(void) { socketOpen(&roSocket, routingReceive); socketBind(&roSocket, ROUTING_PROTOCOL_PORT); alarmInit(&roCheckTimer, roCheckTimerCb, NULL); alarmInit(&roForwardTimer, roForwardTimerCb, NULL); alarmInit(&roOutOfOrderForwardTimer, roOutOfOrderForwardTimerCb, NULL); alarmInit(&roRequestTimer, roRequestTimerCb, NULL); alarmInit(&roStopListeningTimer, roStopListeningTimerCb, NULL); alarmInit(&roStartListeningTimer, roStartListeningTimerCb, NULL); alarmInit(&roGreenLedTimer, roGreenLedTimerCb, NULL); alarmInit(&watchdogTimer, watchdogTimerCb, NULL); alarmSchedule(&roCheckTimer, randomInRange(1000, 3000)); alarmSchedule(&roForwardTimer, calcNextForwardTime(0)); alarmSchedule(&roStartListeningTimer, 110); alarmSchedule(&roGreenLedTimer, 10000); // alarmSchedule(&watchdogTimer, 1000); }
CParticle* CParticleSystem::createParticle(){ if(mParticles.size() >= mDef->mBudget) return 0; CParticle *p = new CParticle(); p->mPosition = CVector3::ZERO; p->mVelocity = CVector3(0.0, 0.0, 0.0); if(mDef->mEmitterShape == PARTICLE_EMITTER_SPHERE){ CVector3 dir = CVector3(randomInRange(-1.0, 1.0), randomInRange(-1.0, 1.0), randomInRange(-1.0, 1.0)).normalized(); p->mPosition = dir * mDef->mEmitterDimensions.x; if(mDef->mSpawnDirection == PARTICLE_SPAWN_DIRECTION_NATURAL){ p->mVelocity = dir * randomInRange(mDef->mSpawnVelocityMin, mDef->mSpawnVelocityMax); } else { p->mVelocity = CVector3(0.0, 0.0, 1.0) * randomInRange(mDef->mSpawnVelocityMin, mDef->mSpawnVelocityMax); } } CVector3 var = CVector3(randomInRange(-1.0, 1.0), randomInRange(-1.0, 1.0), randomInRange(-1.0, 1.0)); p->mVelocity += var * mDef->mSpawnDirectionVariation; if(mEmitter){ p->mPosition += mEmitter->getDerivedPosition(); p->mVelocity = mEmitter->getDerivedOrientation() * p->mVelocity; } if(mDef->mRotation != 0.0) p->mRotation = mDef->mRotation; else p->mRotation = 2 * PI * random(); p->mRotationSpeed = mDef->mRotationSpeed; p->mTimeLived = 0.0; p->mLifetime = mDef->mLifeTime; p->mSizeX = 10.0; p->mSizeY = 10.0; mParticles.push_back(p); return p; }
void ParticalEffect::updateFire(float dt, const int scount, int type) { count = scount; for (int x = 0; x < count; x ++) { if(!partsA[x].active) { int mouseX, mouseY; Core::Input::GetMousePos( mouseX, mouseY ); Vector2D mouse((float)mouseX, (float)mouseY); partsA[x] = Partical(); float randInt = randomInRange(1,10); Vector2D rand; if(type == 1) { rand = RandomUnitVector() * randInt; } else { } Vector2D newPath = mouse + rand; partsA[x].updateFire(dt, mouse, newPath); } } }
void Orbs::makeOrbs() { unsigned maxOrbs = gdata->getXmlInt("orbsNumber"); unsigned minX = gdata->getXmlInt("orbsMinX"); unsigned maxX = gdata->getXmlInt("orbsMaxX"); unsigned minY = gdata->getXmlInt("orbsMinY"); unsigned maxY = gdata->getXmlInt("orbsMaxY"); unsigned minXspeed = gdata->getXmlInt("orbsMinXspeed"); unsigned maxXspeed = gdata->getXmlInt("orbsMaxXspeed"); unsigned minYspeed = gdata->getXmlInt("orbsMinYspeed"); unsigned maxYspeed = gdata->getXmlInt("orbsMaxYspeed"); orbs.push_back( new Sprite( Vector2f(randomInRange(minX, maxX), randomInRange(minY, maxY)), Vector2f(randomInRange(maxXspeed, maxXspeed+100), randomInRange(minYspeed, maxYspeed)), SpriteFrameFactory::getInstance()->getFrame("orb", "cyanOrb"))); orbs.push_back( new Sprite( Vector2f(randomInRange(minX, maxX), randomInRange(minY, maxY)), Vector2f(randomInRange(maxXspeed, 2*maxXspeed+200), randomInRange(minYspeed, maxYspeed)), SpriteFrameFactory::getInstance()->getFrame("orb", "greenOrb"))); for (unsigned i = 0; i < maxOrbs; ++i) { orbs.push_back( new Sprite( Vector2f(randomInRange(minX, maxX), randomInRange(minY, maxY)), Vector2f(randomInRange(minXspeed, maxXspeed), randomInRange(minYspeed, maxYspeed)), SpriteFrameFactory::getInstance()->getFrame("orb", "yellowOrb"))); } for (unsigned i = 0; i < maxOrbs; ++i) { orbs1.push_back( new Sprite( Vector2f(randomInRange(minX, maxX), randomInRange(minY, maxY)), Vector2f(randomInRange(minXspeed, maxXspeed), randomInRange(minYspeed, maxYspeed)), SpriteFrameFactory::getInstance()->getFrame("orb", "yellowOrb1"))); } }
void wasmint::TestCaseGenerator::generateInstruction(const wasm_module::Type* expectedReturnType) { instructions++; TestCaseInstruction* instruction; if (instructions < instructionLimit) { while(true) { std::size_t index = randomInRange(testInstructions.size()); instruction = &testInstructions.at(index); if (expectedReturnType == nullptr) break; if (instruction->returnType == expectedReturnType) break; } } else { if (expectedReturnType == Int32::instance()) { instruction = &leafTestInstructions.at(0); } else if (expectedReturnType == Int64::instance()) { instruction = &leafTestInstructions.at(1); } else if (expectedReturnType == Float32::instance()) { instruction = &leafTestInstructions.at(2); } else if (expectedReturnType == Float64::instance()) { instruction = &leafTestInstructions.at(3); } else { instruction = &leafTestInstructions.at(4); } } source_ << " (" << instruction->name << " "; if (instruction->special) { if (instruction->name == "i32.const") { source_ << randomInRange(1000); } else if (instruction->name == "i64.const") { source_ << randomInRange(1000); } else if (instruction->name == "f32.const") { source_ << randomInRange(1000); } else if (instruction->name == "f64.const") { source_ << randomInRange(1000); } else if (instruction->name == "has_feature") { generateRandomString(); } else if (instruction->name == "get_local") { generateRandomString(); } else if (instruction->name == "set_local") { generateRandomString(); } else if (instruction->name == "label") { generateRandomString(); } else if (instruction->name == "block") { generateRandomString(); } else if (instruction->name == "loop") { generateRandomString(); } else if (instruction->name == "call_import") { generateRandomString(); } else if (instruction->name == "call") { generateRandomString(); } else if (instruction->name == "call_indirect") { generateRandomString(); } else if (instruction->name == "br") { generateRandomString(); } else if (instruction->name == "br_if") { generateRandomString(); } else { std::cerr << "Unknown special instruction during generation " << instruction->name << std::endl; exit(1); } } source_ << " "; if (instructions < instructionLimit) { for (std::size_t i = 0; i < instruction->children.size(); i++) { const Type *expectedChildType = nullptr; if (i < instruction->children.size()) { expectedChildType = instruction->children.at(i); } generateInstruction(expectedChildType); } } source_ << ") "; }
Edge getRandomMoveFromList(Edge * edges, short numEdges) { return edges[randomInRange(0, numEdges-1)]; }
Edge getRandomMove(UnscoredState * state) { Edge freeEdges[NUM_EDGES]; short numFreeEdges = getFreeEdges(state, freeEdges); return freeEdges[randomInRange(0, numFreeEdges-1)]; }