mat kmeans(Array<vec> &DB, int SIZE, int NOITER, bool VERBOSE) { int DIM = DB(0).length(), T = DB.length(); mat codebook(DIM, SIZE); int n, i, j; double D, Dold; ivec ind(SIZE); for (i = 0;i < SIZE;i++) { ind(i) = randi(0, T - 1); j = 0; while (j < i) { if (ind(j) == ind(i)) { ind(i) = randi(0, T - 1); j = 0; } j++; } codebook.set_col(i, DB(ind(i))); } if (VERBOSE) std::cout << "Training VQ..." << std::endl ; D = 1E20; for (n = 0;n < NOITER;n++) { Dold = D; D = kmeansiter(DB, codebook); if (VERBOSE) std::cout << n << ": " << D / T << " "; if (std::abs((D - Dold) / D) < 1e-4) break; } return codebook; }
Gene Gene::createRandomAttribGene() { GeneAttribute g; g.attribute = (gene_part_attribute_type)randi(GENE_ATTRIB_INVALID+1, GENE_ATTRIB_END-1); g.value.set(randf()); g.attribIndex.set(randi(constants::MAX_ATTRIB_INDEX_COUNT)); return g; }
Gene Gene::createRandomJointOffsetGene(int spaceLeftAfter) { GeneJointOffset g; g.maxDepth.set(randi(5)); g.minDepth.set(0); g.offset.set(randi(spaceLeftAfter)); return g; }
Body::Body(BodyType type, float posx, float posy, float velx, float vely) { mType = type; mPos.x = posx; mPos.y = posy; mVel.x = velx; mVel.y = vely; mRotVel = 0; mRot = 0; mTimeOfDeath = 0; int w = Boy::Environment::screenWidth(); int h = Boy::Environment::screenHeight(); switch (mType) { case BIG_ASTEROID: mImage = Boy::Environment::getImage( Boy::UString::format("IMAGE_ASTEROID_BIG_%d",randi(1,3)).toUtf8()); mRadius = 100; do { mPos.x = (float)randi(0,w); mPos.y = (float)randi(0,h); } while (dist(mPos.x,mPos.y,w/2.0f,h/2.0f) < mRadius+100); mVel = rotate(BoyLib::Vector2(BIG_ASTEROID_SPEED, 0), randf(0,6.28f)); mRotVel = randf(-ASTEROID_ROTSPEED,ASTEROID_ROTSPEED); mRot = randf(0,6.28f); break; case MEDIUM_ASTEROID: mImage = Boy::Environment::getImage( Boy::UString::format("IMAGE_ASTEROID_MEDIUM_%d",randi(1,3)).toUtf8()); mRadius = 50; mVel = rotate(BoyLib::Vector2(MEDIUM_ASTEROID_SPEED, 0), randf(0,6.28f)); mRotVel = randf(-ASTEROID_ROTSPEED,ASTEROID_ROTSPEED); mRot = randf(0,6.28f); break; case SMALL_ASTEROID: mImage = Boy::Environment::getImage( Boy::UString::format("IMAGE_ASTEROID_SMALL_%d",randi(1,3)).toUtf8()); mRadius = 25; mVel = rotate(BoyLib::Vector2(SMALL_ASTEROID_SPEED, 0), randf(0,6.28f)); mRotVel = randf(-ASTEROID_ROTSPEED,ASTEROID_ROTSPEED); mRot = randf(0,6.28f); break; case SHIP: mImage = Boy::Environment::getImage("IMAGE_SHIP"); mRadius = 20; mPos.x = w/2.0f; mPos.y = h/2.0f; break; case BULLET: mImage = Boy::Environment::getImage("IMAGE_BULLET"); mRadius = 1; mTimeOfDeath = Boy::Environment::instance()->getTime() + BULLET_DURATION; break; } }
Gene Gene::createRandomProteinGene() { GeneProtein g; g.maxDepth.set(randi(8)); g.minDepth.set(0); g.protein.set((gene_protein_type)randi(GENE_PROT_NONE+1, GENE_PROT_END-1)); g.targetSegment.set(randi(BodyPart::MAX_CHILDREN)); return g; }
Gene Gene::createRandomOffsetGene(int spaceLeftAfter) { GeneOffset g; g.maxDepth.set(randi(5)); g.minDepth.set(0); g.targetSegment.set(randi(BodyPart::MAX_CHILDREN)); g.offset.set(randi(spaceLeftAfter)); return g; }
Gene Gene::createRandomSynapseGene(int nNeurons) { GeneSynapse g; g.from.set(randi(nNeurons-1)); g.to.set(randi(nNeurons-1)); g.weight.set(randf()*0.2f); g.priority.set(randf()*10); return g; }
Gene Gene::createRandomSkipGene(int spaceLeftAfter) { GeneSkip g; g.minDepth.set(randi(10)); g.maxDepth.set(g.minDepth + randi(10-g.minDepth)); // use a random distribution that favors small values: g.count.set(sqr(randd()) * spaceLeftAfter); return g; }
/********************************************************************** * 迭代 **********************************************************************/ void tran() { int i, j, pos; int k; //找当前种群最优个体 min = cur[0]; for ( i=1; i<SIZE-1; i++ ) { if ( cur[i].fitness<min.fitness ) { min = cur[i]; } } for ( k=0; k<SIZE; k+=2 ) { // 选择交叉个体 i = sel(); j = sel(); // 选择交叉位置 pos = randi(LEN-1); //交叉 if ( randd()<P_CORSS ) { memcpy(next[k].x, cur[i].x, pos); memcpy(next[k].x+pos, cur[j].x+pos, LEN-pos); memcpy(next[k+1].x,cur[j].x,pos); memcpy(next[k+1].x+pos,cur[i].x+pos,LEN-pos); } else { memcpy(next[k].x,cur[i].x,LEN); memcpy(next[k+1].x,cur[j].x,LEN); } //变异 if ( randd()<P_MUTATION ) { pos = randi(LEN-1); next[k].x[pos] ^= next[k].x[pos]; pos = randi(LEN-1); next[k+1].x[pos] ^= next[k+1].x[pos]; } } //找下一代的最差个体 max = next[0]; j = 0; for ( i=1; i<SIZE-1; i++ ) { if ( next[i].fitness<min.fitness ) { max = next[i]; j = i; } } //用上一代的最优个体替换下一代的最差个体 next[j] = min; memcpy(cur, next, sizeof(cur)); cal_fitness(); }
Gene Gene::createRandomBodyAttribGene() { GeneBodyAttribute g; g.attribute = (gene_body_attribute_type)randi(GENE_BODY_ATTRIB_INVALID+1, GENE_BODY_ATTRIB_END-1); switch (g.attribute) { case GENE_BODY_ATTRIB_ADULT_LEAN_MASS: g.value.set(BodyConst::initialAdultLeanMass); break; case GENE_BODY_ATTRIB_EGG_MASS: g.value.set(BodyConst::initialEggMass); break; case GENE_BODY_ATTRIB_GROWTH_SPEED: g.value.set(BodyConst::initialGrowthSpeed); break; case GENE_BODY_ATTRIB_INITIAL_FAT_MASS_RATIO: g.value.set(BodyConst::initialFatMassRatio); break; case GENE_BODY_ATTRIB_MIN_FAT_MASS_RATIO: g.value.set(BodyConst::initialMinFatMassRatio); break; case GENE_BODY_ATTRIB_REPRODUCTIVE_MASS_RATIO: g.value.set(BodyConst::initialReproductiveMassRatio); break; default: ERROR("unhandled body attrib type: " << g.attribute); } return g; }
//render between 0-1.0f void render_doids(int _seed) { int old_seed = seed; seed = _seed; { int nboxes = 1 + randi(3); //random size float w = 0.1f + 0.5f*rand01(); float h = (0.7f - w) + 0.5f* rand01(); float hg = 0.01f + 0.2f*rand01(); //pos float x = (1.0f - w) * rand01(); float y = (1.0f - h*nboxes) * rand01(); while(nboxes--) { glPushMatrix(); glTranslatef(x, y + (h+ 0.01f)*nboxes, hg); glScalef(w, h, hg); cube_w(); glPopMatrix(); } } seed = old_seed; }
core::MonteCarloMoverResult RelativePositionMover::do_propose() { last_transformation_ = rbA_.get_reference_frame().get_transformation_to(); ::boost::uniform_real<> zeroone(0., 1.); double p = zeroone(random_number_generator); if (p < probability_of_random_move_) { algebra::Vector3D translation = algebra::get_random_vector_in( algebra::Sphere3D(rbA_.get_coordinates(), max_translation_)); algebra::Vector3D axis = algebra::get_random_vector_on( algebra::Sphere3D(algebra::Vector3D(0.0, 0.0, 0.0), 1.)); ::boost::uniform_real<> rand(-max_angle_, max_angle_); Float angle = rand(random_number_generator); algebra::Rotation3D r = algebra::get_rotation_about_axis(axis, angle); algebra::Rotation3D rc = r * rbA_.get_reference_frame().get_transformation_to().get_rotation(); algebra::Transformation3D t(rc, translation); IMP_LOG_TERSE("proposing a random move " << t << std::endl); // std::cout << "proposing a random move for " << rbA_->get_name() << " " // << rbA_ << " Transformation " << t << std::endl; rbA_.set_reference_frame(algebra::ReferenceFrame3D(t)); } else { ::boost::uniform_int<> randi(0, reference_rbs_.size() - 1); unsigned int i = randi(random_number_generator); ::boost::uniform_int<> randj(0, transformations_map_[i].size() - 1); unsigned int j = randj(random_number_generator); algebra::Transformation3D Tint = transformations_map_[i][j]; IMP_LOG_TERSE("proposing a relative move. Rigid body " << i << "Internal transformation " << j << " " << Tint << std::endl); // std::cout << "Proposing a relative move. Rigid body " << // rbA_->get_name() // << " " << rbA_ << " Relative transformation " << Tint<< std::endl; // core::RigidBody rb = reference_rbs_[i]; algebra::Transformation3D T_reference = reference_rbs_[i].get_reference_frame().get_transformation_to(); // std::cout << "RF receptor ===> " << T_reference << std::endl; // new absolute reference frame for the rigid body of the ligand algebra::Transformation3D Tdock = algebra::compose(T_reference, Tint); rbA_.set_reference_frame(algebra::ReferenceFrame3D(Tdock)); // std::cout << "Finished proposing. Reference frame for the ligand" // << rbA_.get_reference_frame() << std::endl; } return core::MonteCarloMoverResult( ParticleIndexes(1, rbA_.get_particle_index()), 1.0); }
void Shell::explode () { QList<QScriptProgram> programs = scene->shellPrograms().values(); QScriptProgram shellProgram = programs[randi(programs.size())]; Cluster* cluster = new Cluster(d->trx.getOrigin(), shellProgram, scene); connect(scene, SIGNAL(update(qreal)), cluster, SLOT(update(qreal))); connect(scene, SIGNAL(drawClusters()), cluster, SLOT(draw())); }
int *random_indicies_new(struct tree *t1, struct tree *t2) { int *indicies = malloc(sizeof(int) * 2); if (t1->size > 2) { indicies[0] = randi(0, t1->size - 2); } else { indicies[0] = 0; } if (t2->size > 2) { indicies[1] = randi(0, t2->size - 2); } else { indicies[1] = 0; } return indicies; }
//manage all bullet control void final_boss_fire(struct actor_t* a) { random_ship_t* s = (random_ship_t*)a->child; if(boss_timers.global-- == 0) { boss_timers.burst = 2 + randi(12); boss_timers.cburst = 0; boss_timers.inter_burst = 15 + randi(30); boss_timers.cinter_burst = boss_timers.inter_burst; boss_timers.type = randi(2) == 0?FIRE_RANDOM: FIRE_STAR; boss_timers.global = 90 + randi(200); } boss_timers.cinter_burst--; if(boss_timers.cinter_burst == 0) { boss_timers.burst--; if(boss_timers.burst >= 0) { switch(boss_timers.type) { case FIRE_RANDOM: boss_random_fire(a,7); break; case FIRE_STAR: boss_star_fire(a, 1.0f); break; } boss_timers.cinter_burst = boss_timers.inter_burst; } } }
bool test_once(shenidam_t processor, float* base,size_t total_num_samples,double sample_rate,size_t num_samples_track, double sigma) { int real_in = randi(0,total_num_samples-num_samples_track-1); float* track = (float*) std::malloc(num_samples_track*sizeof(float)); std::memcpy(track,&base[real_in],num_samples_track*sizeof(float)); add_gaussian_noise(track,num_samples_track,sigma); size_t dummy; int in; shenidam_get_audio_range(processor,FORMAT_SINGLE,track,num_samples_track,sample_rate,&in,&dummy); std::free(track); return std::abs(in - real_in)<sample_rate*threshold; }
/***************************************************************************** * Population initial *****************************************************************************/ void population_init() { int tmp; int i; int j; for ( i=0; i<SIZE; i++ ) { tmp = randi(N); for ( j=0; j<LEN; j++ ) { cur[i].x[j] = tmp%2; tmp = tmp>>1; } } cal_fitness(); }
void synth_residual_only(float a1, float a2,float freq,float frame_samps,int op,float *oscpt, RANDI* rdata) { int k, samps=(int)frame_samps; float a_inc, amp; float out=0.; if(a1!=0. || a2!=0.) { //no synthesis if no amplitude amp = a1; a_inc= (a2 - a1) / frame_samps; for(k=0; k<samps; k++) { out = ioscilator(amp,freq,op,oscpt); amp += a_inc; frbuf[k] += out * sparams->ramp * randi(rdata); } } }
void final_boss_init(struct actor_t* a) { a->pos[2] = -100.0f; SHIP_generate(a, randi(12312312), 13, 6); a->collide_size[0] = 13.0f; a->collide_size[1] = 4.0f; boss_timers.global = 0; boss_timers.burst = 0; boss_timers.inter_burst = 0; final_boss = a; a->life = 1.1f; }
static int do_quick_select(int *v, int low, int high, int k) { if (low == high) return v[low]; int pivot = randi(low, high), size_l; pivot = partition(v, low, high, pivot); size_l = pivot - low; if (toc() > TIME_LIMIT) return ABORTED; if (size_l == k - 1) return v[pivot]; else if (size_l > k - 1) return do_quick_select(v, low, pivot - 1, k); else return do_quick_select(v, pivot + 1, high, k - size_l - 1); }
/* This is the main routine, doRun. It is a bank of 2x6 randomly varying delays which feed back into themselves in a tricky way. */ void RVB::doRun(double *input, double *output, long counter) { register int i, j; double sig, delsig; for (i = 0; i < 2; ++i) { /* loop for 2 output chans */ output[i] = 0.0; for (j = 0; j < 6; ++j) { /* loop for 6 delays per chan */ ReverbData *rvb = &m_rvbData[i][j]; ReverbData *rvb2 = rvb; sig = input[i] + rvb->delin; /* combine input w/ delay return */ /* get new delay length (random) then put samp into delay & get new delayed samp out */ double delay = Nsdelay[i][j] + randi(&rvb->Rand_info[0]); delsig = delpipe(sig, &rvb->deltap, delay, rvbdelsize, &rvb->Rvb_del[0]); #ifdef USE_BUGGY_CODE if (i == 1 && j > 0) rvb2 = &m_rvbData[0][j]; // remap "incorrectly" #endif /* filter with air simulation filters, set gains */ rvb->delout = tone(delsig, &rvb2->Rvb_air[0]); /* sum outputs of all delays for 2 channels */ output[i] += rvb->delout; } /* run outputs through Allpass filter */ double sigout = Allpass(output[i], &allpassTap[i], Allpass_del[i]); #ifdef USE_HI_PASS output[i] = 0.51 * sigout - 0.49 * m_rvbPast[i]; // Hi pass FIR filter m_rvbPast[i] = sigout; #else output[i] = sigout; #endif } /* redistribute delpipe outs into delpipe ins */ matrix_mix(); }
/* NOTE: This is identical to randmtzig_gv_randn() below except for the random number generation */ double randmtzig_randn (dsfmt_t *dsfmt) { while (1) { /* arbitrary mantissa (selected by randi, with 1 bit for sign) */ const randmtzig_uint64_t r = randi(dsfmt); const randmtzig_int64_t rabs=r>>1; const int idx = (int)(rabs&0xFF); const double x = ( r&1 ? -rabs : rabs) * wi[idx]; if (rabs < (randmtzig_int64_t)ki[idx]) { return x; /* 99.3% of the time we return here 1st try */ } else if (idx == 0) { /* As stated in Marsaglia and Tsang * * For the normal tail, the method of Marsaglia[5] provides: * generate x = -ln(U_1)/r, y = -ln(U_2), until y+y > x*x, * then return r+x. Except that r+x is always in the positive * tail!!!! Any thing random might be used to determine the * sign, but as we already have r we might as well use it * * [PAK] but not the bottom 8 bits, since they are all 0 here! */ double xx, yy; do { xx = - ZIGGURAT_NOR_INV_R * log (randu(dsfmt)); yy = - log (randu(dsfmt)); } while ( yy+yy <= xx*xx); return (rabs&0x100 ? -ZIGGURAT_NOR_R-xx : ZIGGURAT_NOR_R+xx); } else if ((fi[idx-1] - fi[idx]) * randu(dsfmt) + fi[idx] < exp(-0.5*x*x)) { return x; } } }
Gene Gene::createRandomNeuronOutputCoordGene(int nNeurons) { GeneNeuronOutputCoord g; g.srcNeuronVirtIndex.set(randi(nNeurons-1)); g.outCoord.set(randf() * BodyConst::MaxVMSCoordinateValue); return g; }
UBool ResourceBundleTest::testTag(const char* frag, UBool in_Root, UBool in_te, UBool in_te_IN) { int32_t failOrig = fail; // Make array from input params UBool is_in[] = { in_Root, in_te, in_te_IN }; const char* NAME[] = { "ROOT", "TE", "TE_IN" }; // Now try to load the desired items char tag[100]; UnicodeString action; int32_t i,j,actual_bundle; // int32_t row,col; int32_t index; UErrorCode status = U_ZERO_ERROR; const char* testdatapath; testdatapath=loadTestData(status); if(U_FAILURE(status)) { dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(status))); return FALSE; } for (i=0; i<bundles_count; ++i) { action = "Constructor for "; action += param[i].name; status = U_ZERO_ERROR; ResourceBundle theBundle( testdatapath, *param[i].locale, status); //ResourceBundle theBundle( "c:\\icu\\icu\\source\\test\\testdata\\testdata", *param[i].locale, status); CONFIRM_UErrorCode(status, param[i].expected_constructor_status, action); if(i == 5) actual_bundle = 0; /* ne -> default */ else if(i == 3) actual_bundle = 1; /* te_NE -> te */ else if(i == 4) actual_bundle = 2; /* te_IN_NE -> te_IN */ else actual_bundle = i; UErrorCode expected_resource_status = U_MISSING_RESOURCE_ERROR; for (j=e_te_IN; j>=e_Root; --j) { if (is_in[j] && param[i].inherits[j]) { if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */ expected_resource_status = U_ZERO_ERROR; else if(j == 0) expected_resource_status = U_USING_DEFAULT_WARNING; else expected_resource_status = U_USING_FALLBACK_WARNING; break; } } UErrorCode expected_status; UnicodeString base; for (j=param[i].where; j>=0; --j) { if (is_in[j]) { base = NAME[j]; break; } } //-------------------------------------------------------------------------- // string uprv_strcpy(tag, "string_"); uprv_strcat(tag, frag); action = param[i].name; action += ".getString("; action += tag; action += ")"; status = U_ZERO_ERROR; UnicodeString string(theBundle.getStringEx(tag, status)); if(U_FAILURE(status)) { string.setTo(TRUE, kErrorUChars, kErrorLength); } CONFIRM_UErrorCode(status, expected_resource_status, action); UnicodeString expected_string(kErrorUChars); if (U_SUCCESS(status)) { expected_string = base; } CONFIRM_EQ(string, expected_string, action); //-------------------------------------------------------------------------- // array uprv_strcpy(tag, "array_"); uprv_strcat(tag, frag); action = param[i].name; action += ".get("; action += tag; action += ")"; status = U_ZERO_ERROR; ResourceBundle arrayBundle(theBundle.get(tag, status)); CONFIRM_UErrorCode(status, expected_resource_status, action); int32_t count = arrayBundle.getSize(); if (U_SUCCESS(status)) { CONFIRM_GE(count, 1, action); for (j=0; j < count; ++j) { char buf[32]; UnicodeString value(arrayBundle.getStringEx(j, status)); expected_string = base; expected_string += itoa(j,buf); CONFIRM_EQ(value, expected_string, action); } action = param[i].name; action += ".getStringEx("; action += tag; action += ")"; for (j=0; j<100; ++j) { index = count ? (randi(count * 3) - count) : (randi(200) - 100); status = U_ZERO_ERROR; string = kErrorUChars; UnicodeString t(arrayBundle.getStringEx(index, status)); expected_status = (index >= 0 && index < count) ? expected_resource_status : U_MISSING_RESOURCE_ERROR; CONFIRM_UErrorCode(status, expected_status, action); if (U_SUCCESS(status)) { char buf[32]; expected_string = base; expected_string += itoa(index,buf); } else { expected_string = kErrorUChars; } CONFIRM_EQ(string, expected_string, action); } } else if (status != expected_resource_status) { record_fail("Error getting " + (UnicodeString)tag); return (UBool)(failOrig != fail); } } return (UBool)(failOrig != fail); }
UBool NewResourceBundleTest::testTag(const char* frag, UBool in_Root, UBool in_te, UBool in_te_IN) { int32_t failOrig = fail; // Make array from input params UBool is_in[] = { in_Root, in_te, in_te_IN }; const char* NAME[] = { "ROOT", "TE", "TE_IN" }; // Now try to load the desired items char tag[100]; UnicodeString action; int32_t i,j,row,col, actual_bundle; int32_t index; const char* testdatapath; UErrorCode status = U_ZERO_ERROR; testdatapath=loadTestData(status); if(U_FAILURE(status)) { dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(status))); return FALSE; } for (i=0; i<bundles_count; ++i) { action = "Constructor for "; action += param[i].name; status = U_ZERO_ERROR; ResourceBundle theBundle( testdatapath, *param[i].locale, status); //ResourceBundle theBundle( "c:\\icu\\icu\\source\\test\\testdata\\testdata", *param[i].locale, status); CONFIRM_UErrorCode(status,param[i].expected_constructor_status); if(i == 5) actual_bundle = 0; /* ne -> default */ else if(i == 3) actual_bundle = 1; /* te_NE -> te */ else if(i == 4) actual_bundle = 2; /* te_IN_NE -> te_IN */ else actual_bundle = i; UErrorCode expected_resource_status = U_MISSING_RESOURCE_ERROR; for (j=e_te_IN; j>=e_Root; --j) { if (is_in[j] && param[i].inherits[j]) { if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */ expected_resource_status = U_ZERO_ERROR; else if(j == 0) expected_resource_status = U_USING_DEFAULT_WARNING; else expected_resource_status = U_USING_FALLBACK_WARNING; break; } } UErrorCode expected_status; UnicodeString base; for (j=param[i].where; j>=0; --j) { if (is_in[j]) { base = NAME[j]; break; } } //-------------------------------------------------------------------------- // string uprv_strcpy(tag, "string_"); uprv_strcat(tag, frag); action = param[i].name; action += ".getStringEx("; action += tag; action += ")"; status = U_ZERO_ERROR; UnicodeString string = theBundle.getStringEx(tag, status); if(U_FAILURE(status)) { string.setTo(TRUE, kErrorUChars, kErrorLength); } CONFIRM_UErrorCode(status, expected_resource_status); UnicodeString expected_string(kErrorUChars); if (U_SUCCESS(status)) { expected_string = base; } CONFIRM_EQ(string, expected_string); //-------------------------------------------------------------------------- // array ResourceBundle using the key uprv_strcpy(tag, "array_"); uprv_strcat(tag, frag); action = param[i].name; action += ".get("; action += tag; action += ")"; int32_t count = kERROR_COUNT; status = U_ZERO_ERROR; ResourceBundle array = theBundle.get(tag, status); CONFIRM_UErrorCode(status,expected_resource_status); if (U_SUCCESS(status)) { //confirm the resource type is an array UResType bundleType=array.getType(); CONFIRM_EQ(bundleType, URES_ARRAY); count=array.getSize(); CONFIRM_GE(count,1); for (j=0; j<count; ++j) { char buf[32]; expected_string = base; expected_string += itoa(j,buf); CONFIRM_EQ(array.getNextString(status),expected_string); } } else { CONFIRM_EQ(count,kERROR_COUNT); // CONFIRM_EQ((int32_t)(unsigned long)array,(int32_t)0); count = 0; } //-------------------------------------------------------------------------- // arrayItem ResourceBundle using the index for (j=0; j<100; ++j) { index = count ? (randi(count * 3) - count) : (randi(200) - 100); status = U_ZERO_ERROR; string = kErrorUChars; ResourceBundle array = theBundle.get(tag, status); if(!U_FAILURE(status)){ UnicodeString t = array.getStringEx(index, status); if(!U_FAILURE(status)) { string=t; } } expected_status = (index >= 0 && index < count) ? expected_resource_status : U_MISSING_RESOURCE_ERROR; CONFIRM_UErrorCode(status,expected_status); if (U_SUCCESS(status)){ char buf[32]; expected_string = base; expected_string += itoa(index,buf); } else { expected_string = kErrorUChars; } CONFIRM_EQ(string,expected_string); } //-------------------------------------------------------------------------- // 2dArray uprv_strcpy(tag, "array_2d_"); uprv_strcat(tag, frag); action = param[i].name; action += ".get("; action += tag; action += ")"; int32_t row_count = kERROR_COUNT, column_count = kERROR_COUNT; status = U_ZERO_ERROR; ResourceBundle array2d=theBundle.get(tag, status); //const UnicodeString** array2d = theBundle.get2dArray(tag, row_count, column_count, status); CONFIRM_UErrorCode(status,expected_resource_status); if (U_SUCCESS(status)) { //confirm the resource type is an 2darray UResType bundleType=array2d.getType(); CONFIRM_EQ(bundleType, URES_ARRAY); row_count=array2d.getSize(); CONFIRM_GE(row_count,1); for(row=0; row<row_count; ++row){ ResourceBundle tablerow=array2d.get(row, status); CONFIRM_UErrorCode(status, expected_resource_status); if(U_SUCCESS(status)){ //confirm the resourcetype of each table row is an array UResType rowType=tablerow.getType(); CONFIRM_EQ(rowType, URES_ARRAY); column_count=tablerow.getSize(); CONFIRM_GE(column_count,1); for (col=0; j<column_count; ++j) { char buf[32]; expected_string = base; expected_string += itoa(row,buf); expected_string += itoa(col,buf); CONFIRM_EQ(tablerow.getNextString(status),expected_string); } } } }else{ CONFIRM_EQ(row_count,kERROR_COUNT); CONFIRM_EQ(column_count,kERROR_COUNT); row_count=column_count=0; } //-------------------------------------------------------------------------- // 2dArrayItem for (j=0; j<200; ++j) { row = row_count ? (randi(row_count * 3) - row_count) : (randi(200) - 100); col = column_count ? (randi(column_count * 3) - column_count) : (randi(200) - 100); status = U_ZERO_ERROR; string = kErrorUChars; ResourceBundle array2d=theBundle.get(tag, status); if(U_SUCCESS(status)){ ResourceBundle tablerow=array2d.get(row, status); if(U_SUCCESS(status)) { UnicodeString t=tablerow.getStringEx(col, status); if(U_SUCCESS(status)){ string=t; } } } expected_status = (row >= 0 && row < row_count && col >= 0 && col < column_count) ? expected_resource_status: U_MISSING_RESOURCE_ERROR; CONFIRM_UErrorCode(status,expected_status); if (U_SUCCESS(status)){ char buf[32]; expected_string = base; expected_string += itoa(row,buf); expected_string += itoa(col,buf); } else { expected_string = kErrorUChars; } CONFIRM_EQ(string,expected_string); } //-------------------------------------------------------------------------- // taggedArray uprv_strcpy(tag, "tagged_array_"); uprv_strcat(tag, frag); action = param[i].name; action += ".get("; action += tag; action += ")"; int32_t tag_count; status = U_ZERO_ERROR; ResourceBundle tags=theBundle.get(tag, status); CONFIRM_UErrorCode(status, expected_resource_status); if (U_SUCCESS(status)) { UResType bundleType=tags.getType(); CONFIRM_EQ(bundleType, URES_TABLE); tag_count=tags.getSize(); CONFIRM_GE((int32_t)tag_count, (int32_t)0); for(index=0; index <tag_count; index++){ ResourceBundle tagelement=tags.get(index, status); UnicodeString key=tagelement.getKey(); UnicodeString value=tagelement.getNextString(status); logln("tag = " + key + ", value = " + value ); if(key.startsWith("tag") && value.startsWith(base)){ record_pass(); }else{ record_fail(); } } for(index=0; index <tag_count; index++){ ResourceBundle tagelement=tags.get(index, status); const char *tkey=NULL; UnicodeString value=tagelement.getNextString(&tkey, status); UnicodeString key(tkey); logln("tag = " + key + ", value = " + value ); if(value.startsWith(base)){ record_pass(); }else{ record_fail(); } } }else{ tag_count=0; } //-------------------------------------------------------------------------- // taggedArrayItem action = param[i].name; action += ".get("; action += tag; action += ")"; count = 0; for (index=-20; index<20; ++index) { char buf[32]; status = U_ZERO_ERROR; string = kErrorUChars; char item_tag[8]; uprv_strcpy(item_tag, "tag"); uprv_strcat(item_tag, itoa(index,buf)); ResourceBundle tags=theBundle.get(tag, status); if(U_SUCCESS(status)){ ResourceBundle tagelement=tags.get(item_tag, status); if(!U_FAILURE(status)){ UResType elementType=tagelement.getType(); CONFIRM_EQ(elementType, (int32_t)URES_STRING); const char* key=tagelement.getKey(); CONFIRM_EQ((UnicodeString)key, (UnicodeString)item_tag); UnicodeString t=tagelement.getString(status); if(!U_FAILURE(status)){ string=t; } } if (index < 0) { CONFIRM_UErrorCode(status,U_MISSING_RESOURCE_ERROR); } else{ if (status != U_MISSING_RESOURCE_ERROR) { count++; expected_string = base; expected_string += buf; CONFIRM_EQ(string,expected_string); } } } } CONFIRM_EQ(count, tag_count); } return (UBool)(failOrig == fail); }
void GMapHome::generate(int dW, int dH) { // Generate home // Set // Width int hWidth = 10 + randi(10); // Height int hHeight = hWidth/2; // Create clear slots for(int mX = -hWidth; mX < alignX(dW) + hWidth*2; mX++) { // X int x = cameraX(alignX(dW)) + mX; for(int mY = -hHeight; mY < alignY(dH) + hHeight*2; mY++) { // Y int y = cameraY(alignY(dH)) + mY; // Create slot[x][y] = new GMapSlot(); } } // Home coords const int homeX = -hWidth/2; const int homeY = -hHeight/2; // Generate // Home for(int mX = -hWidth/2; mX < hWidth/2; mX++) { for(int mY = -hHeight/2; mY < hHeight/2; mY++) { slot[mX][mY] = generateSlot(); } } // Walls // Up / Down for(int mX = -hWidth/2; mX <= hWidth/2; mX++) { // Wall slot[mX][-hHeight/2] = &gMapSlotWall; slot[mX][hHeight/2] = &gMapSlotWall; } // Left / Right for(int mY = -hHeight/2; mY <= hHeight/2; mY++) { // Wall slot[-hWidth/2][mY] = &gMapSlotWall; slot[hWidth/2][mY] = &gMapSlotWall; } // Door // Select angle (left up / right down) // Left Up int angleX = homeX; int angleY = homeY; bool leftUp = true; // Right down if(luck(50.0f)) { angleX *= -1; angleY *= -1; leftUp = false; } // Get indent int indentX = 1+randi(hWidth-2); int indentY = 1+randi(hHeight-2); if(!leftUp) { indentX *= -1; indentY *= -1; } // Set int doorX = angleX + indentX; int doorY = angleY + indentY; if(luck(50.0f)) { slot[homeX][doorY] = &gMapSlotDoor; doorX = angleX; } else { slot[doorX][homeY] = &gMapSlotDoor; doorY = angleY; } // Set player coords // Get int playerX_ = getPlayerX(); int playerY_ = getPlayerY(); if(leftUp) { if(angleX == doorX) { playerX_ = doorX+1; playerY_ = doorY; } else if(angleY == doorY) { playerY_ = doorY+1; playerX_ = doorX; } } else { if(angleX == doorX) { playerX_ = doorX-1; playerY_ = doorY; } else if(angleY == doorY) { playerY_ = doorY-1; playerX_ = doorX; } } // Set setPlayerX(playerX_); setPlayerY(playerY_); // Set free generated slot of player coords GMapSlot *slot_; while(!slot[getPlayerX()][getPlayerY()]->is_free()) { // Generate slot_ = generateSlot(); // Set slot[playerX_][playerY_] = slot_; } // Generated setGenerated(true); }
mat vqtrain(Array<vec> &DB, int SIZE, int NOITER, double STARTSTEP, bool VERBOSE) { int DIM = DB(0).length(); vec x; vec codebook(DIM*SIZE); int n, MinIndex, i, j; double MinS, S, D, step, *xp, *cp; for (i = 0;i < SIZE;i++) { codebook.replace_mid(i*DIM, DB(randi(0, DB.length() - 1))); } if (VERBOSE) std::cout << "Training VQ..." << std::endl ; res: D = 0; for (n = 0;n < NOITER;n++) { step = STARTSTEP * (1.0 - double(n) / NOITER); if (step < 0) step = 0; x = DB(randi(0, DB.length() - 1)); // seems unnecessary! Check it up. xp = x._data(); MinS = 1E20; MinIndex = 0; for (i = 0;i < SIZE;i++) { cp = &codebook(i * DIM); S = sqr(xp[0] - cp[0]); for (j = 1;j < DIM;j++) { S += sqr(xp[j] - cp[j]); if (S >= MinS) goto sune; } MinS = S; MinIndex = i; sune: i = i; } D += MinS; cp = &codebook(MinIndex * DIM); for (j = 0;j < DIM;j++) { cp[j] += step * (xp[j] - cp[j]); } if ((n % 20000 == 0) && (n > 1)) { if (VERBOSE) std::cout << n << ": " << D / 20000 << " "; D = 0; } } // checking training result vec dist(SIZE), num(SIZE); dist.clear(); num.clear(); for (n = 0;n < DB.length();n++) { x = DB(n); xp = x._data(); MinS = 1E20; MinIndex = 0; for (i = 0;i < SIZE;i++) { cp = &codebook(i * DIM); S = sqr(xp[0] - cp[0]); for (j = 1;j < DIM;j++) { S += sqr(xp[j] - cp[j]); if (S >= MinS) goto sune2; } MinS = S; MinIndex = i; sune2: i = i; } dist(MinIndex) += MinS; num(MinIndex) += 1; } dist = 10 * log10(dist * dist.length() / sum(dist)); if (VERBOSE) std::cout << std::endl << "Distortion contribution: " << dist << std::endl ; if (VERBOSE) std::cout << "Num spread: " << num / DB.length()*100 << " %" << std::endl << std::endl ; if (min(dist) < -30) { std::cout << "Points without entries! Retraining" << std::endl ; j = min_index(dist); i = max_index(num); codebook.replace_mid(j*DIM, codebook.mid(i*DIM, DIM)); goto res; } mat cb(DIM, SIZE); for (i = 0;i < SIZE;i++) { cb.set_col(i, codebook.mid(i*DIM, DIM)); } return cb; }
bool randb() { return randi(0, 1) ? true : false; }
Gene Gene::createRandomNeuralParamGene(int nNeurons) { GeneNeuralParam g; g.targetNeuron.set(randi(nNeurons-1)); g.value.set(srandf()); return g; }
Gene Gene::createRandomTransferFuncGene(int nNeurons) { GeneTransferFunction g; g.functionID.set(randi((int)transferFuncNames::FN_MAXCOUNT-1)); g.targetNeuron.set(randi(nNeurons-1)); return g; }