C++ random_number函数代码示例

static void connect_rooms(cell_t *cell_arr, room_t *room_arr, int num_room)
{
  int i, x, y;
  path_node_c_t *path_arr, *curr_p;
  heap_t *h;
  room_t *room;

  h = (heap_t *) malloc(sizeof(*h));

  for(i = 1; i < num_room; i++)
    {
      room = room_arr + i;
      x = random_number(room->x, room->x + room->width - 1);
      y = random_number(room->y, room->y + room->height - 1);
   
      heap_init(h, gen_path_node_cmp, NULL);
      path_arr = (path_node_c_t *) malloc(MAP_HEIGHT * MAP_WIDTH *
				  sizeof(*path_arr));
      initialize_heap(h, path_arr, cell_arr);
           
      curr_p = path_arr + (MAP_WIDTH * y) + x;
      curr_p->weight = 1;
      curr_p->distance = 0;
      curr_p->previous = NULL;
      heap_decrease_key_no_replace(h, curr_p->heap_node);

      create_corridor(h, path_arr);

      room = room_arr + i - 1;
      x = random_number(room->x, room->x + room->width - 1);
      y = random_number(room->y, room->y + room->height - 1);
      curr_p = path_arr + (MAP_WIDTH * y) + x;

      place_corridor(curr_p, cell_arr);

      heap_delete(h);
      free(path_arr);
    }
  
  free(h);
}

void updateWorld()
{
	for(int n = 0; n < (0.5*P.N); ++n)
	{
		//pick a random cell
		int x = random_number(P.sizeX);
		int y = random_number(P.sizeY);
		bool picked_viable = (bool)viable[x][y];
		while(picked_viable == false)
		{
			x = random_number(P.sizeX);
			y = random_number(P.sizeY);
			picked_viable = (bool)viable[x][y];
		}


		//species at x,y dies and gets replaced
		//with prob 1-m it is from within the local community
		if(uniform() < P.m) //migration
		{
			species migrant = getSpeciesFromMetaCommunity();
			world[x][y] = migrant;
		}
		else //no migration, local reproduction
		{
			int otherX = x; int otherY = y;
			if(P.dispersalType == "Square") findParent_Square(otherX,otherY,x,y); //square
			else if(P.dispersalType == "Circle") findParent_Circle(otherX,otherY,x,y); //circle
//			else if(P.dispersalType == "Reflect") findParent_Reflect(otherX,otherY,x,y);
			else findParent_Circle(otherX,otherY,x,y);  //default


			world[x][y] = world[otherX][otherY];
			reproduction[otherX][otherY]++;
			//world[x][y] = world[otherX][otherY];


			if(uniform() < P.speciationRate) world[x][y] = newSpecies();
		}
	}
}

void
f_oldcrypt (void) {
    char *res, salt[3];
    const char *choice =
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ./";

    if (sp->type == T_STRING && SVALUE_STRLEN(sp) >= 2) {
        salt[0] = sp->u.string[0];
        salt[1] = sp->u.string[1];
        free_string_svalue(sp--);
    } else {
        salt[0] = choice[random_number(strlen(choice))];
        salt[1] = choice[random_number(strlen(choice))];
        pop_stack();
    }
    salt[2] = 0;
    res = string_copy(OLDCRYPT(sp->u.string, salt), "f_crypt");
    free_string_svalue(sp);
    sp->subtype = STRING_MALLOC;
    sp->u.string = res;
}

void
f_roll_MdN() {
   long roll = 0;

   if ( (sp - 1)->u.number > 0 && sp->u.number > 0 ) {
      while( (sp - 1)->u.number-- )
         roll += 1 + random_number( sp->u.number );
   }

   pop_stack();            // Pop one...
   sp->u.number = roll;    // And change the other!
}

void update(RenderWindow & window, Group & group) {
	if (group.location == 1) {
		group.direction = random_number(4);
		group.efect_number = random_number(3);
		group.location++;
	}
	if (group.location == 2) {
		switch (group.direction)
		{
		case 1: group.left(); break;
		case 2: group.right(); break;
		case 3: group.up(); break;
		case 4: group.down(); break;
		}
		switch (group.efect_number)
		{
		case 1: group.effect_color(); break;
		case 2: group.effect_rotate(); break;
		case 3: group.effect_size(); break;
		}

	}
	if (group.location == 3) {

		switch (group.efect_number)
		{
		case 1: group.effect_color(); break;
		case 2: group.effect_rotate(); break;
		case 3: group.effect_size(); break;
		}

		switch (group.direction)
		{
		case 1: group.back_from_left(); break;
		case 2: group.back_from_right(); break;
		case 3: group.back_from_up(); break;
		case 4: group.back_from_down(); break;
		}
	}
}

void test_hash_set()
{
# if !(defined (_MSC_VER) && (_MSC_VER < 1100))
  TestSet testSet, testSet2;

        const size_t hash_setSize = random_number(random_base);

  while ( testSet.size() < hash_setSize )
  {
    TestSet::value_type x;
    testSet.insert( x );
    testSet2.insert( TestSet::value_type() );
  }

#  if defined( EH_HASH_CONTAINERS_SUPPORT_RESIZE )
  WeakCheck( testSet, test_hash_resize<TestSet>() );
  // TestMultiSet == TestMultiSet: no such operator! - ptr
  // StrongCheck( testSet, test_insert_noresize<TestSet>(testSet) );
#  endif
  WeakCheck( testSet, test_insert_value<TestSet>(testSet) );

  size_t insCnt = random_number(random_base);
  TestSet::value_type *insFirst = new TestSet::value_type[1+insCnt];
  WeakCheck( testSet, insert_range_tester(testSet, insFirst, insFirst+insCnt) );
  ConstCheck( 0, test_construct_pointer_range<TestSet>(insFirst, insFirst+insCnt) );
  delete[] insFirst;

  WeakCheck( testSet, insert_range_tester(testSet, testSet2.begin(), testSet2.end() ) );

  ConstCheck( 0, test_default_construct<TestSet>() );
#  if EH_HASH_CONTAINERS_SUPPORT_ITERATOR_CONSTRUCTION
  ConstCheck( 0, test_construct_iter_range_n<TestSet>( testSet2 ) );
#  endif
  ConstCheck( testSet, test_copy_construct<TestSet>() );

  WeakCheck( testSet, test_assign_op<TestSet>( testSet2 ) );
# endif
}

void test_deque()
{
    EH_STD::size_t dequeSize = random_number(random_base);
    TestDeque emptyDeque;
    TestDeque testDeque, testDeque2;
    while ( testDeque.size() < dequeSize )
    {
        DQTestClass x;
        testDeque.push_back( x );
        testDeque2.push_back( DQTestClass() );
    }

    ConstCheck( testDeque, test_copy_construct<TestDeque>() );
    WeakCheck( testDeque, test_insert_one<TestDeque>(testDeque) );
    StrongCheck( testDeque, test_insert_one<TestDeque>(testDeque,0) );
    StrongCheck( testDeque, test_insert_one<TestDeque>(testDeque, testDeque.size()) );

    WeakCheck( testDeque, test_insert_n<TestDeque>(testDeque, random_number(random_base) ) );
    StrongCheck( testDeque, test_insert_n<TestDeque>(testDeque, random_number(random_base), 0 ) );
    StrongCheck( testDeque, test_insert_n<TestDeque>(testDeque, random_number(random_base), testDeque.size() ) );

    EH_STD::size_t insCnt = random_number(random_base);
    DQTestClass *insFirst = new TestDeque::value_type[insCnt+1];

    WeakCheck( testDeque, insert_range_tester(testDeque, (DQTestClass *)insFirst, 
					      insFirst+insCnt) );
    StrongCheck( testDeque, insert_range_at_begin_tester(testDeque, (DQTestClass *)insFirst,
							 insFirst+insCnt) );
    StrongCheck( testDeque, insert_range_at_end_tester(testDeque, (DQTestClass *)insFirst, 
						       insFirst+insCnt) );

    ConstCheck( 0, test_construct_pointer_range<TestDeque>( (DQTestClass *)insFirst, 
							    insFirst+insCnt ) );
    delete[] insFirst;

    WeakCheck( testDeque, insert_range_tester(testDeque, testDeque2.begin(), testDeque2.end() ) );

    StrongCheck( testDeque, test_push_back<TestDeque>(testDeque) );
    StrongCheck( emptyDeque, test_push_back<TestDeque>(emptyDeque) );
    StrongCheck( testDeque, test_push_front<TestDeque>(testDeque) );
    StrongCheck( emptyDeque, test_push_front<TestDeque>(emptyDeque) );


    ConstCheck( 0, test_default_construct<TestDeque>() );
    ConstCheck( 0, test_construct_n<TestDeque>( random_number(random_base) ) );
    ConstCheck( 0, test_construct_n_instance<TestDeque>( random_number(random_base) ) );
    ConstCheck( 0, test_construct_iter_range<TestDeque>( testDeque2 ) );

    testDeque2.resize( testDeque.size() * 3 / 2 );
    WeakCheck( testDeque, test_assign_op<TestDeque>( testDeque2 ) );
    testDeque2.resize( testDeque.size() * 2 / 3 );
    WeakCheck( testDeque, test_assign_op<TestDeque>( testDeque2 ) );
}

blueParticle::blueParticle(float x, float y, float dirx, float diry,GameState *state) : Particle(dirx,diry,state)
{	
	Load(state->getApp()->gettextureManager().Get("Content/particle.png"));

	_colour = sf::Color(139,137,137,180);

	SetPosition(x,y);

	life_time_ = random_number( 0.08f, 0.3f );

	direction = sf::Vector2f(dirx,diry);

	speed = rand() % 40 + 90;     // v2 in the range 1 to 100
}

int init_branches(Triple *branches,
                  const EllipticCurve ec,
                  const Point P, 
                  const Point Q)
{
    BigInt aj, bj;
    int i;

    for(i = 0; i < L; i++) {
        Point Rj, Ptemp, Qtemp;

        aj = random_number(ec.order);
        bj = random_number(ec.order);
        ecc_mul(Ptemp, ec, aj, P);
        ecc_mul(Qtemp, ec, bj, Q);
        ecc_add(Rj, ec, Ptemp, Qtemp);
        branches[i].c = aj;
        branches[i].d = bj;
        branches[i].point = Rj;
    }

    return 0;
}

planets * starSystem::distributePlanetaryMasses(double inner_dust, double outer_dust)
{
	double
		a,
		e,
		mass,
		crit_mass,
		planetesimal_inner_bound,
		planetesimal_outer_bound;

	dust_bands* dust_head=new dust_bands(inner_dust,outer_dust);
	planets *planet_head=0;
	planets *&temp=planet_head;
	isDustLeft=TRUE;
	cloudEccentricity=0.2;

	planetesimal_inner_bound = innermost_planet(starMass);
	planetesimal_outer_bound = outermost_planet(starMass);

	while (isDustLeft)
	{
		a = random_number(planetesimal_inner_bound,planetesimal_outer_bound);
		e = random_eccentricity( );
		mass = PROTOPLANET_MASS;
#ifdef VERBOSE
		printf("Checking %10f AU:  ",a);
#endif
		if (dust_head->dustAvailable(inner_effect_limit(a, e, mass),outer_effect_limit(a, e, mass)))
		{
#ifdef VERBOSE
			printf(".. Injecting protoplanet.\n");
#endif
			assert(a>0.0);
			dustDensity = DUST_DENSITY_COEFF * sqrt(starMass) * exp(-ALPHA * pow(a,(1.0 / N)));
			crit_mass = critical_limit(a,e,starLuminosity);
			accreteDust(dust_head,mass,a,e,crit_mass,planetesimal_inner_bound,planetesimal_outer_bound);

			if ((mass != 0.0) && (mass != PROTOPLANET_MASS))
				coalescePlanetesimals(planet_head,dust_head,a,e,mass,crit_mass,
						planetesimal_inner_bound,planetesimal_outer_bound);
#ifdef VERBOSE
			else printf(".. failed due to large neighbor.\n");
#endif
		}
#ifdef VERBOSE
		else printf(".. failed.\n");
#endif
	}
	return temp;
}

npc::npc(cell_t *cell_arr, room_t *room_arr, int num_room, int seq)
{
  traits = 0;
  choose_traits();

  turn = 0;
  seen_x = 150;
  seen_y = 150;
  sequence = seq;

  speed = random_number(5, 20);

  place_monster(cell_arr, room_arr, num_room);
}

static void random_string(int length, char *str) {
    int i;
    int char_type;

    for (i = 0; i < length; i++) {
        char_type = (int) (3 * (rand() / (RAND_MAX + 1.0)));

        switch (char_type) {
            case 0:
                str[i] = random_letter(0);
                break;
            case 1:
                str[i] = random_letter(1);
                break;
            case 2:
                str[i] = random_number();
                break;
            default:
                str[i] = random_number();
                break;
        }
    }
}

Vec refraction_reflection(const Vec &x , int depth, const Sphere &sph, const Ray &r, const Vec &n, const Vec &f, const Vec &nl){
	Ray ray_refraction; 
  ray_refraction.origin= x; 
  ray_refraction.direction= r.direction-n*2*dot(n,r.direction);    


  double r_index_air=1, r_index_glass=1.5;
  double r_index, ddn=dot(r.direction,nl), cos2t=0;
  double temp111, temp112;
  if(dot(n,nl)>0){
  	r_index = r_index_air/r_index_glass;
  	temp111 = 1;
  }
  else {
  	r_index = r_index_glass/r_index_air;
  	temp111 = -1;
  }

  Vec tdir = norm((r.direction*r_index - n*((temp111)*(ddn*r_index+sqrt(cos2t)))));

  if(dot(n,nl)>0){
  	temp112 = -ddn;
  }
  else {
  	temp112 = dot(tdir,n);
  }
  
  double a=r_index_glass-r_index_air;
  double b=r_index_glass+r_index_air;
  double c = 1-(temp112);
  double R0=a*a/(b*b), Re=R0+(1-R0)*c*c*c*c*c,Tr=1-Re,P=.25+.5*Re,RP=Re/P,TP=Tr/(1-P);
  Ray rr3; 
  rr3.origin = x; 
  rr3.direction =tdir;

  Vec temp_vector;
  if(depth>2){
    if(random_number()<P){
      temp_vector = calculate_light(ray_refraction,depth)*RP;
    }
    else{
      temp_vector = calculate_light(rr3,depth)*TP;
    }
  }
  else{
    temp_vector = calculate_light(ray_refraction,depth)*Re+calculate_light(rr3,depth)*Tr;
  }
  return sph.light + mult(f,temp_vector);

}

bool zz_camera_follow::apply_shake (zz_time diff_time)
{
	if (shake_lifetime == 0) return false;

	if (shake_lifetime <= diff_time) {
		shake_lifetime = 0; // do not modify
		return true;
	}
	else {
		shake_lifetime -= diff_time;
	}

	vec3 shakeed_cam_pos, shakeed_target_pos;

	vec3 shake_min_shrinked(shake_min), shake_max_shrinked(shake_max);

	shakeed_cam_pos = random_number(final_.camera_pos + shake_min_shrinked, final_.camera_pos + shake_max_shrinked);
	shakeed_target_pos = random_number(last_.target_pos + shake_min_shrinked, last_.target_pos + shake_max_shrinked);

	look_at(shakeed_cam_pos, shakeed_target_pos, vec3(0, 0, 1));

	return true;
}

int main()
{
    set_random_limit(1000);
    clock_t tbeg = clock();
    int i = 1;
    while(true) {
        int tm = random_number();
        std::cout<<"["<<i<<"]\t"<<tm<<"\t";
        ++i;
        if (i>1000) break;
        tm = random_number();
        std::cout<<"["<<i<<"]\t"<<tm<<"\t";
        tm = random_number();
        ++i;
        if (i>1000) break;
        std::cout<<"["<<i<<"]\t"<<tm<<"\n";
        ++i;
        if (i>1000) break;
    }
    clock_t tend = clock();
    std::cout<<"______________\ntakes "<<static_cast<double>(tend-tbeg)/CLOCKS_PER_SEC
             <<" seconds\n";
    return 0;
}