示例#1
0
void pingpong_mutate_shift(population *pop, entity *mother, entity *son)
  {
  int		i, j, k;	/* Team members. */
  int		tmp;		/* For swapping i and j. */

/* Copy chromosomes of parent to offspring. */
  memcpy( son->chromosome[0],
          mother->chromosome[0],
          pop->len_chromosomes*sizeof(int) );

  i = random_int(9);

  do
    {
    j = random_int(9);
    } while(i==j);

  if (i>j)
    {
    tmp = ((int *)son->chromosome[0])[j];
    for (k=j; k<i; k++)
      {
      ((int *)son->chromosome[0])[k] = ((int *)son->chromosome[0])[k+1];
      }
    ((int *)son->chromosome[0])[i] = tmp;
    }
  else
    {
    tmp = ((int *)son->chromosome[0])[j];
    for (k=j; k>i; k--)
      {
      ((int *)son->chromosome[0])[k] = ((int *)son->chromosome[0])[k-1];
      }
    ((int *)son->chromosome[0])[i] = tmp;
    }

  return;
  }
示例#2
0
void init(void)
{
  fault_handling_setup();
  reset_callback_register();

  nap_version_check();
  nap_auth_check();
  nap_callbacks_setup();

  rng_setup();
  srand(random_int());

  stm_unique_id_callback_register();
}
示例#3
0
	Node* generate_terminal_node(std::mt19937& random, bool is_ghost)
	{
		if (is_ghost)
		{
			switch (random_int(random, 0, 2))
			{
			case 0: return createNodeFromInt(random, Constant); break;
			case 1: return createNodeFromInt(random, GhostToGhost); break;
			case 2: return createNodeFromInt(random, GhostToPacman); break;
			}
		}
		else
		{
			switch (random_int(random, 0, 3))
			{
			case 0: return createNodeFromInt(random, Constant); break;
			case 1: return createNodeFromInt(random, PacmanToDot); break;
			case 2: return createNodeFromInt(random, PacmanToGhost); break;
			case 3: return createNodeFromInt(random, PacmanDotsEaten); break;
			}
		}
		return nullptr;
	}
示例#4
0
void wildfire_mutate_flip(population *pop, entity *mother, entity *son)
  {
  int		i;	/* Map square. */

  /* Copy chromosome. */
  for(i=0; i<WILDFIRE_X_DIMENSION*WILDFIRE_Y_DIMENSION; i++)
    ((int *)son->chromosome[0])[i] = ((int *)mother->chromosome[0])[i];

  /* Mutation. */
  i = random_int(WILDFIRE_X_DIMENSION*WILDFIRE_Y_DIMENSION);
  ((int *)son->chromosome[0])[i] = !((int *)son->chromosome[0])[i];

  return;
  }
示例#5
0
pointer list_to_int(pointer a) {
  int res=0;
  char *dispatch;
  if (is_symbol(car(a))) {
    dispatch=sym_name(car(a));
    if (!strcmp(dispatch,"random"))
      return random_int(cadr(a),caddr(a));
    else
      return Error_1("list>int: unknown dispatch type:",car(a));
  }
  else
    return Error_1("list>int: no symbol:",car(a));
  return mk_integer(res);
}
void anneal(instance *t, solution *s)
{
    double temperature = INITIAL_TEMPERATURE;

    initialize_solution(t->n, s);
    double current_value = solution_cost(s, t);

    for (int i = 1; i <= COOLING_STEPS; i++)
    {
        temperature *= COOLING_FRACTION;

        double start_value = current_value;

        for (int j = 1; j <= STEPS_PER_TEMP; j++)
        {
            int i1 = random_int(1, t->n);
            int i2 = random_int(2, t->n);

            double flip = random_float(0, 1);

            double delta = transition(s, t, i1, i2);
            double exponent = (-delta / current_value) / (K * temperature);
            double merit = pow(E, exponent);

            if (delta < 0)
                current_value = current_value + delta;
            else
                if (merit > flip)
                    current_value = current_value + delta;
                else
                    transition(s, t, i1, i2);
        }

        if ((current_value - start_value) < 0.0)
            temperature = temperature / COOLING_FRACTION;
    }
}
示例#7
0
文件: rtp.c 项目: Aaron1011/toxcore
RTPSession *rtp_new ( int payload_type, Messenger *messenger, int friend_num )
{
    RTPSession *retu = calloc(1, sizeof(RTPSession));

    if ( !retu ) {
        LOGGER_WARNING("Alloc failed! Program might misbehave!");
        return NULL;
    }

    if ( -1 == custom_lossy_packet_registerhandler(messenger, friend_num, payload_type, rtp_handle_packet, retu)) {
        LOGGER_ERROR("Error setting custom register handler for rtp session");
        free(retu);
        return NULL;
    }

    LOGGER_DEBUG("Registered packet handler: pt: %d; fid: %d", payload_type, friend_num);

    retu->version   = RTP_VERSION;   /* It's always 2 */
    retu->padding   = 0;             /* If some additional data is needed about the packet */
    retu->extension = 0;           /* If extension to header is needed */
    retu->cc        = 1;           /* Amount of contributors */
    retu->csrc      = NULL;        /* Container */
    retu->ssrc      = random_int();
    retu->marker    = 0;
    retu->payload_type = payload_type % 128;

    retu->dest = friend_num;

    retu->rsequnum = retu->sequnum = 0;

    retu->ext_header = NULL; /* When needed allocate */


    if ( !(retu->csrc = calloc(1, sizeof (uint32_t))) ) {
        LOGGER_WARNING("Alloc failed! Program might misbehave!");
        free(retu);
        return NULL;
    }

    retu->csrc[0] = retu->ssrc; /* Set my ssrc to the list receive */

    /* Also set payload type as prefix */
    retu->prefix = payload_type;

    /*
     *
     */
    return retu;
}
示例#8
0
int random_int_()
  /*@ requires [?f]world(?pub, ?key_clsfy) &*&
               proof_obligations(pub) &*&
               principal(?principal, ?count) &*&
               true == bad(principal); @*/
  /*@ ensures  [f]world(pub, key_clsfy) &*&
               proof_obligations(pub) &*&
               principal(principal, count + 1); @*/
{
  //@ open proof_obligations(pub);
  //@ assert is_public_nonce(?proof, _);
  //@ proof(nonce_item(principal, count + 1, 0));
  return random_int();
  //@ close proof_obligations(pub);
}
示例#9
0
int test_random()
{
	int i, j, result = 0;
	test_msg_start("Test Random Number Generator - Integers 0 to 100");
		random_seed();
		j = 0;
		while(j < 100000) {
			i = random_int(0,100);
			if(i < 0 || i > 100) result++;
			j++;
		}
	test_msg_end(result);

	return result;
}
示例#10
0
 void MixtureDataPolicy::add_data(const Ptr<DataType> &d) {
   dat().push_back(d);
   int max_levels = pkey_->max_levels();
   if (max_levels > 0) {
     uint h = random_int(0, max_levels - 1);
     NEW(CategoricalData, pcat)(h, pkey_);
     latent_data().push_back(pcat);
   } else {
     NEW(CategoricalData, pcat)(uint(0), pkey_);
     latent_data().push_back(pcat);
   }
   if (!known_data_source_.empty()) {
     known_data_source_.push_back(-1);
   }
 }
示例#11
0
const GIndividual* GPopulation::choose_individual() const
{
    if (gd.selection_method == GenDef::SELECTION_TOURNAMENT)
    {
        const GIndividual* a1 = individuals[ random_int( individuals.size() ) ];
        const GIndividual* a2 = individuals[ random_int( individuals.size() ) ];
        if (gd.use_parsimony && 
            a1->raw_fitness >= gd.parsimony_threshhold &&
            a2->raw_fitness >= gd.parsimony_threshhold)
        {
            if (fabs( a1->raw_fitness - a2->raw_fitness ) <= 1.0)
            {
                if ( a1->alg->num_children() < a2->alg->num_children() )
                    return a1;
                else
                    return a2;
            }
        }

        if (a1->raw_fitness > a2->raw_fitness)
            return a1;
        else
            return a2;
    }
    else // fitness proportionate
    {
        double f = static_cast<double>(random_float( 1.0 ));
        for( unsigned i = 0; i < individuals.size(); i++ )
        {
            f -= individuals[i]->normalized_fitness;
            if (f <= 0.0f)
                return individuals[i];
        }
    }
    return individuals[0];
}
示例#12
0
文件: actor.c 项目: kilogram/EE319K
void addenemy(unsigned short type) {
	int i; enemy *typ;
	if (type >= sizeof(enemy_list)) type = sizeof(enemy_list)-1;
	typ = (enemy*)&enemy_list[type];
	for (i = 0; i < MAX_ENEMIES; i++) {
		enemy_ref *curr = &enemies[i];
		if (curr->health >= 0) continue;
		curr->type = typ;
		curr->health = typ->start_health;
		curr->counter = 0;
		if (typ->start_x < 0) 
			curr->x = (random_int() % (127-(typ->size<<1))) +
				typ->size + 1;
		else
			curr->x = typ->start_x;
		
		if (typ->start_y < 0)
			curr->y = (random_int() % (95-(typ->size<<1))) + 
				typ->size + 1;
		else
			curr->y = typ->start_y;
		break;
	}
}
示例#13
0
void choose_reduced_pilots()
{
	int i, reduced, count, num_pilots = 2 * m;

	if (k > 0) {
		reduced = (num_pilots * k / 100.0);
		count = 0;
		while (count < reduced) {
			i = random_int(0, num_pilots - 1);
			if (!pilots[i]->reduce) {
				++count;
				pilots[i]->reduce = 1;	
			}		
		}		
	}
}
示例#14
0
static int * random_array (int minval, int maxval, size_t len)
{
  int * arr;
  int * ii;
  
  arr = malloc (len * sizeof(int));
  if (NULL == arr) {
    err (EXIT_FAILURE, __FILE__": %s: malloc", __func__);
  }
  
  for (ii = arr; len > 0; ++ii, --len) {
    *ii = random_int (minval, maxval);
  }
  
  return arr;
}
示例#15
0
void CNetTokenManager::GenerateSeed()
{
	static const NETADDR NullAddr = { 0 };
	m_PrevSeed = m_Seed;

	for(int i = 0; i < 2; i++)
	{
		m_Seed <<= 32;
		m_Seed ^= random_int();
	}

	m_PrevGlobalToken = m_GlobalToken;
	m_GlobalToken = GenerateToken(&NullAddr);

	m_NextSeedTime = time_get() + time_freq() * m_SeedTime;
}
示例#16
0
JSBool js_event_start_wait_random_func(JSContext *cx,JSObject *j_obj,uintN argc,jsval *argv,jsval *rval)
{
	int				min,max,tick;
	
	min=JSVAL_TO_INT(argv[0]);
	max=JSVAL_TO_INT(argv[1]);
	tick=random_int(abs(max-min))+min;
	
	if (!timers_add(&js.attach,tick,JSVAL_TO_INT(argv[2]),NULL,timer_mode_single)) {
		*rval=JSVAL_FALSE;
	}
    else {
		*rval=JSVAL_TRUE;
	}

    return(JS_TRUE);
}
示例#17
0
	Node* generate_tree_up_to(std::mt19937& random, int max_levels, bool is_ghost)
	{
		if (max_levels <= 0) return nullptr;
		if (max_levels == 1)
		{
			return generate_terminal_node(random, is_ghost);
		}
		else
		{
			Node* parent = generate_parent_node(random);
			for (int child_index = 0; child_index < parent->GetMinChildren(); ++child_index)
			{
				parent->children.emplace_back(generate_tree(random, random_int(random, 1, max_levels - 1), is_ghost));
			}
			return parent;
		}
	}
示例#18
0
void screen_fx_random(){
	int x, y;
	random_seed();
	for(x=0; x < WIDTH; x++){
		for(y = 0; y < HEIGHT; y++){
			s[x][y].bg_bl = (float)random_int(1,10000)/10000;
			s[x][y].bg_rd = (float)random_int(1,10000)/10000;
			s[x][y].bg_gr = (float)random_int(1,10000)/10000;
			s[x][y].fg_bl = (float)random_int(1,10000)/10000;
			s[x][y].fg_rd = (float)random_int(1,10000)/10000;
			s[x][y].fg_gr = (float)random_int(1,10000)/10000;
			s[x][y].ch = random_int(0, 128);
		}
	}
}
示例#19
0
void robot_manager::add_user(room_user uinfo)
{
    guard g(m_mutex);
    bool is_ok = false;
    do 
    {
        if(uinfo.coin < config_manager::instance()->get_ac().less_coin)
        {
            break;
        }
        else if(config_manager::instance()->get_ac().max_coin > 0 &&
            uinfo.coin > config_manager::instance()->get_ac().max_coin)
        {
            break;
        }
        is_ok = true;
    } while (false);

    if(!is_ok)
    {
        if(!cfg_inst->is_ai_auto_supplement())
        {
            db_thread::instance()->on_logout(uinfo.uid);
            return;
        }
        int coin = random_int(cfg_inst->ai_supplement_from(), cfg_inst->ai_supplement_to());
        int dc = (int)(coin - uinfo.coin);
        uinfo.coin = coin;
        db_thread::instance()->on_add_coin(AI_SUPPLEMENT, uinfo.uid, dc);
    }

    map<unsigned int, room_user>::iterator i;
    i = m_robot.find(uinfo.uid);
    if(i == m_robot.end())
    {
        m_robot[uinfo.uid] = uinfo;
        m_idle.push(&m_robot[uinfo.uid]);
        i = m_robot.find(uinfo.uid);
    }
    else
    {
        i->second.coin = uinfo.coin;
        i->second.vip = uinfo.vip;
    }
}
示例#20
0
GAULFUNC void random_int_permutation(const int size, int *iarray, int *oarray)
  {
  int		i,j=0;		/* Loop variables over arrays. */
  int		pos;		/* Randomly selected index. */
  
  if (!iarray || !oarray) die("NULL pointer to int array passed.");

  for (i=size-1; i>0; i--)
    {
    pos = random_int(i);
    oarray[j++] = iarray[pos];
    iarray[pos] = iarray[i];
    }

  oarray[j] = iarray[0];

  return;
  }
示例#21
0
   Project(Display *display, Player *player)
      : NewWorldScreen(display, player)
      , bitmaps("data")
      , motion()
      , tile_index()
   {
      level = new Level();
      current_map = new Map();
      level->maps.push_back(current_map);

      tile_index.load_from_atlas(bitmaps["spritesheet.png"], 21, 21, 2, 2, 1, 1);
      current_map->tile_layers.push_back(TileLayer(&tile_index, 60, 60));

      // fill our map with random tiles
      for (unsigned x=0; x<current_map->tile_layers.back().width; x++)
         for (unsigned y=0; y<current_map->tile_layers.back().height; y++)
            current_map->tile_layers.back().set_tile(x, y, random_int(0, 200));
   }
示例#22
0
void CEffects::PlayerDeath(vec2 Pos, int ClientID)
{
	vec3 BloodColor(1.0f,1.0f,1.0f);

	if(ClientID >= 0)
	{
		if(m_pClient->m_GameInfo.m_GameFlags&GAMEFLAG_TEAMS)
		{
			int ColorVal = m_pClient->m_pSkins->GetTeamColor(m_pClient->m_aClients[ClientID].m_aUseCustomColors[CSkins::SKINPART_BODY], m_pClient->m_aClients[ClientID].m_aSkinPartColors[CSkins::SKINPART_BODY],
																m_pClient->m_aClients[ClientID].m_Team, CSkins::SKINPART_BODY);
			BloodColor = m_pClient->m_pSkins->GetColorV3(ColorVal);
		}
		else
		{
			if(m_pClient->m_aClients[ClientID].m_aUseCustomColors[CSkins::SKINPART_BODY])
				BloodColor = m_pClient->m_pSkins->GetColorV3(m_pClient->m_aClients[ClientID].m_aSkinPartColors[CSkins::SKINPART_BODY]);
			else
			{
				const CSkins::CSkinPart *s = m_pClient->m_pSkins->GetSkinPart(CSkins::SKINPART_BODY, m_pClient->m_aClients[ClientID].m_SkinPartIDs[CSkins::SKINPART_BODY]);
				if(s)
					BloodColor = s->m_BloodColor;
			}
		}
	}

	for(int i = 0; i < 64; i++)
	{
		CParticle p;
		p.SetDefault();
		p.m_Spr = SPRITE_PART_SPLAT01 + (random_int()%3);
		p.m_Pos = Pos;
		p.m_Vel = RandomDir() * ((frandom()+0.1f)*900.0f);
		p.m_LifeSpan = 0.3f + frandom()*0.3f;
		p.m_StartSize = 24.0f + frandom()*16;
		p.m_EndSize = 0;
		p.m_Rot = frandom()*pi*2;
		p.m_Rotspeed = (frandom()-0.5f) * pi;
		p.m_Gravity = 800.0f;
		p.m_Friction = 0.8f;
		vec3 c = BloodColor * (0.75f + frandom()*0.25f);
		p.m_Color = vec4(c.r, c.g, c.b, 0.75f);
		m_pClient->m_pParticles->Add(CParticles::GROUP_GENERAL, &p);
	}
}
示例#23
0
/* run this at startup */
Messenger *initMessenger(void)
{
    Messenger *m = calloc(1, sizeof(Messenger));

    if ( ! m )
        return NULL;

    IP ip;
    ip.i = 0;
    m->net = new_networking(ip, PORT);

    if (m->net == NULL) {
        free(m);
        return NULL;
    }

    m->net_crypto = new_net_crypto(m->net);

    if (m->net_crypto == NULL) {
        kill_networking(m->net);
        free(m);
        return NULL;
    }

    m->dht = new_DHT(m->net_crypto);

    if (m->dht == NULL) {
        kill_net_crypto(m->net_crypto);
        kill_networking(m->net);
        free(m);
        return NULL;
    }

    new_keys(m->net_crypto);
    m_set_statusmessage(m, (uint8_t *)"Online", sizeof("Online"));

    friendreq_init(&(m->fr), m->net_crypto);
    LANdiscovery_init(m->dht);
    set_nospam(&(m->fr), random_int());
    init_cryptopackets(m->dht);

    return m;
}
示例#24
0
文件: rain.c 项目: prophile/dim3
void rain_setup(int tick,int cx,int cy,int cz)
{
	int				n;
	rain_draw_type	*rain_draw;

	rain_draw=view.rain_draws;

	for (n=0;n!=max_rain_density;n++) {
		rain_setup_single(rain_draw,cx,cy,cz);
		rain_draw++;
	}
	
	rain_last_tick=tick;
	
	rain_slant_add=random_int(map.rain.slant_add);
	rain_slant_ang_y=random_float(360);
	
	rain_setup_next_slant(tick);
}
示例#25
0
int main(void)
{
	int i,j;
	rcc_setup();
	gpio_setup();
	rng_setup();
	while(1){
		uint32_t rnd;
		rnd = random_int();
		for(i=0;i!=32;++i){
			if ( (rnd & (1 << i))!=0 )
				gpio_set(GPIOD, GPIO12);
			else
				gpio_clear(GPIOD, GPIO12);
			/* Delay */
			for(j=0;j!=5000000;++j)
				__asm__("nop");
		}		
	}
}
示例#26
0
	Node* generate_tree(std::mt19937& random, int levels, bool is_ghost)
	{
		if (levels <= 0) return nullptr;
		if (levels == 1)
		{
			return generate_terminal_node(random, is_ghost);
		}
		else
		{
			Node* parent = generate_parent_node(random);
			// Make first child have levels - 1 levels in order to gaurantee `levels` levels
			parent->children.emplace_back(generate_tree(random, levels - 1, is_ghost));
			// Make other children have random between 1, and levels - 1 levels
			for (int child_index = 1; child_index < parent->GetMinChildren(); ++child_index)
			{
				parent->children.emplace_back(generate_tree(random, random_int(random, 1, levels - 1), is_ghost));
			}
			return parent;
		}
	}
示例#27
0
文件: Client.c 项目: z-neil/308-310
/** constructor
 @return an object or a null pointer if the object couldn't be created */
struct Client *Client(void) {
	struct Client *client;

	if(!(client = malloc(sizeof(struct Client)))) {
		perror("Client constructor");
		Client_(&client);
		return 0;
	}
	client->is_running= 0;
	client->id        = unique++;
	client->ms_idle   = time_between_prints;
	client->pages_min = min_page;
	client->pages_max = max_page;
	client->prints    = random_int(min_prints, max_prints);
	random_name(client->name);
	fprintf(stderr, "Client: new, %s (%d) #%p.\n", client->name, client->id, (void *)client);
	/*fixme! post(empty);*/

	return client;
}
示例#28
0
static u8 choose_prn(void)
{
  u32 total_score = 0;
  gps_time_t t = get_current_time();

  for (u8 prn=0; prn<32; prn++) {
    if ((acq_prn_param[prn].state != ACQ_PRN_ACQUIRING) ||
         acq_prn_param[prn].masked)
      continue;

    acq_prn_param[prn].score[ACQ_HINT_WARMSTART] =
      manage_warm_start(prn, t,
                        &acq_prn_param[prn].dopp_hint_low,
                        &acq_prn_param[prn].dopp_hint_high);

    for (enum acq_hint hint = 0; hint < ACQ_HINT_NUM; hint++) {
      total_score += acq_prn_param[prn].score[hint];
    }
  }

  u32 pick = random_int() % total_score;

  for (u8 prn=0; prn<32; prn++) {
    if ((acq_prn_param[prn].state != ACQ_PRN_ACQUIRING) ||
         acq_prn_param[prn].masked)
      continue;

    u32 sat_score = 0;
    for (enum acq_hint hint = 0; hint < ACQ_HINT_NUM; hint++)
      sat_score += acq_prn_param[prn].score[hint];
    if (pick < sat_score) {
      return prn;
    } else {
      pick -= sat_score;
    }
  }

  log_error("Failed to pick a sat for acquisition!");

  return -1;
}
  //----------------------------------------------------------------------
  void Group::distribute_total(const Vector &beta, double sigma){
    if (unit_data_.size() <= 1){
      unit_data_[0]->set_y(f(total_value_));
      return;
    }
    if(fabs(sum(unit_values_) - total_value_) > .01){
      report_error("TODO(stevescott):  need descriptive error here");
    }

    beta_ = & beta;
    sigma_ = sigma;
    for(int i = 0; i < unit_data_.size(); ++i){
      // Draw j uniformly from the remaining indicies not equal to i.
      int j = random_int(0, unit_data_.size() - 2);
      if (j >= i) ++j;

      modify_unit_value(i, j);
      unit_data_[i]->set_y(f(unit_values_[i]));
      unit_data_[j]->set_y(f(unit_values_[j]));
    }
  }
示例#30
0
文件: script_event.c 项目: rzel/dim3
JSValueRef js_event_start_wait_random_func(JSContextRef cx,JSObjectRef func,JSObjectRef j_obj,size_t argc,const JSValueRef argv[],JSValueRef *exception)
{
	int				min,max,tick,script_idx;
	char			err_str[256];
	
	if (!script_check_param_count(cx,func,argc,3,exception)) return(script_null_to_value(cx));
	if (!script_check_fail_in_construct(cx,func,j_obj,exception)) return(script_null_to_value(cx));
	
	script_idx=(int)JSObjectGetPrivate(j_obj);
	
	min=script_value_to_int(cx,argv[0]);
	max=script_value_to_int(cx,argv[1]);
	tick=random_int(abs(max-min))+min;
	
	if (!timers_add(script_idx,tick,script_value_to_int(cx,argv[2]),NULL,timer_mode_single,err_str)) {
		*exception=script_create_exception(cx,err_str);
		return(script_bool_to_value(cx,FALSE));
	}

	return(script_bool_to_value(cx,TRUE));
}