void startCentipede(Centipede centipedes[], int *bodyCount)
{
  int direction, x, i;

  direction = LEFT + random2(1);

  x = random2(30) + 1; // 1-31, so starts minimum of one from edge
  if(direction == RIGHT)
    x += 5; // guarantee room for body to left of mouth

  for(i = 0; i < 6; i++)
  {
    centipedes[i].direction = direction;
    centipedes[i].icon = BODY;
    centipedes[i].y = TOP;

    if(direction == LEFT)
      centipedes[i].x = x + i;
    else // moving RIGHT
      centipedes[i].x = x - i;
    
    centipedes[i].icon_below = crt[TOP][centipedes[i].x];
    putChar(centipedes[i].icon, centipedes[i].x, TOP);
  } // for each centipede body part

  if(direction == RIGHT)
    centipedes[0].icon = '{';
  else
    centipedes[0].icon = '}';

  putChar(centipedes[0].icon, centipedes[0].x, TOP);
  *bodyCount = 6;
}  // startCentipede()
Example #2
0
void startTetromino(Tetromino *tetromino)
{
    tetromino->location = random2(5) + 1;
    tetromino->pattern = random2(6);
    tetromino->rotation = 0;
    printTetromino(tetromino, 'X');
} // startTetromino()
Example #3
0
File: hall.c Project: Asiim/Kino
int8_t freeOnePlace(uint8_t room,uint8_t row,uint8_t column)
{
  if (roomOutOfBound(room))
  {
    room=random2(MAX_HALLS);
    printf("room=%" PRIu8,room);
  }
  if(rowOutOfBound(row))
  {
    row=random2(MAX_ROWS);
    printf("row=%" PRIu8,row);
  }
  if(columnOutOfBound(column))
  {
      column=random2(MAX_COLUMNS);
      printf("column=%" PRIu8,column);
  }
  if (hall[room].chair[row][column]==FREE)
  {
    return 1;
  }
  else
  {
    hall[room].chair[row][column]=FREE;
    return 0;
  }
}
Example #4
0
double dexprand()
/*  Generates a double exponentially distributed random variable
      with mean 0 and variance 2.                                 */
{
 double  a,random2();

 a= -log(random2());
 if( random2()>0.5 )   a=(-a);
 return(a);
}
Example #5
0
void Controller::randomizeSettings() {
	auto& settings = m_currDrawer->settings();
	auto& settingsRanges = m_currDrawer->settingsRanges();

    for (auto& setting: settings) {
    	auto& range = settingsRanges.find(setting.first)->second;
    	setting.second = random2() % (range.second - range.first + 1) + range.first;
    } 

    m_currPalIndex = random2() % m_palettes.size();
    m_currDrawer->reset();
    m_drawerChangeTimer.reset();
}
Example #6
0
void Lic::doPixelImage(int width, int height, int pix, coDoPixelImage **pixels)
{
    long seed = -37;
    int PIXEL_SIZE = pix;
    int PIXEL_FORMAT = pix;

    int num_pixels = (width) * (height);
    int img_size = PIXEL_SIZE * num_pixels;

    char *image = new char[img_size];

    {
        for (int i = 0; i < num_pixels; i++)
        {
            if (PIXEL_SIZE == 1)
            {
                image[i] = static_cast<char>(255.0 * random2(&seed) + 0.5);
                if (image[i] < 128)
                {
                    image[i] = 0;
                }
                else
                {
                    image[i] = 255;
                }
            }
            else if (PIXEL_SIZE == 4)
            {
                image[4 * i] = static_cast<unsigned char>(255.0 * random2(&seed) + 0.5);
                image[4 * i + 1] = static_cast<unsigned char>(255.0 * random2(&seed) + 0.5);
                image[4 * i + 2] = static_cast<unsigned char>(255.0 * random2(&seed) + 0.5);
                image[4 * i + 3] = 255;
            }
            else
            {
                Covise::sendError("\"Unimplemented\" Pixel Size");
                return;
            }
        }
    }

    char *name = new char[strlen(textureOutPort->getObjName()) + 5];
    strcpy(name, textureOutPort->getObjName());
    strcat(name, "_Img");

    *pixels = new coDoPixelImage(name, width, height, PIXEL_FORMAT, PIXEL_SIZE,
                                 image);

    return;
}
Example #7
0
int main() {
  int answer, count=5;
  int a, b, n;
  int goodAnswers=0, badAnswers=0;
  
  while( count-- ){
    a=random();
    b=random2();

    printf("%i * %i = ", a, b);
    getResult(&answer); 
    
    n = checkAnswer(a, b, answer);
    giveFeedback(n, a, b);
  
    if( n==1 )
      goodAnswers +=1;
    else
      badAnswers +=1;
 
  }
  printf("\nYou got %i answer(s) correctly and %i answer(s) incorrectly!\n\n", 
	 goodAnswers, badAnswers);
  
  return 0;
}
Example #8
0
double normal()
/*  Generates normal random numbers: N(0,1)  */
{
 static int32_t   even = 1;  /*   if  even = 0:  return b              */
			 /*       even = 1:  compute 2 new values  */
 static double   b;      /*   temporary storage                    */
 double a,r,theta,random2();

 if((even=!even)) {
    return(b);
 } else {
    theta=2*PI*random2();
    r=sqrt(-2*log(random2()));
    a=r*cos(theta);
    b=r*sin(theta);
    return(a);
 }
}
Example #9
0
/////////////////////////////////////////////////////////
// random
//
/////////////////////////////////////////////////////////
void newWave :: noise(float rnd)
{
    int i, j;
    for (i=0; i<gridX; i++)
        for ( j=0;j<gridY; j++)
        {
            force[i][j] += rnd * (double)random2() * (1. / 2147483648.) - rnd/2;
        }
}
void startNewScreen(Centipede centipedes[], int counts[14][38], int sparkXs[14],
  int score, int wandX, int *bodyCount)
{
  int i, j, direction, x, y;
  char str[10];

  erase();  // clear screen completely
  for(x = 0; x < 38; x++)
    for(y = 0; y < 14; y++)
    {
      crt[y][x] = ' ';
      counts[y][x] = 0;
    } // for y

  mvaddstr(0,0,"----------------------------------------");

  for(y = 1; y < 15; y++)
    mvaddstr(y, 0, "|                                      |");

  mvaddstr(15,0,"----------------------------------------");
  mvaddstr(16,0,"Borders are not in CUSP");
  showScore(score);

  for(i = 0; i < 14; i++)
    sparkXs[i] = NO_SPARK;  // no spark at each row

  startCentipede(centipedes, bodyCount);

  for(i = 0; i < 20; i++)
  {
    y = random2(11) + 1;
    x = random2(37);
    random2(5); // to avoid having all y's even and x's odd
    putChar(MUSHROOM, x, y);
    counts[y][x] = 4;
  }

  putChar(WAND, wandX, BOTTOM);
  refresh();
} // StartNewScreen()
Example #11
0
void WorldTestUnitAi :: initRingParticles ()
{
	static const Vector3 A_CLUMP_CENTER[2] =
	{
		Vector3(0.0, 0.0,  RING_CLUMP_DISTANCE),
		Vector3(0.0, 0.0, -RING_CLUMP_DISTANCE),
	};

	for(unsigned int i = 0; i < RING_PARTICLE_COUNT_MAX; i++)
	{
		assert(i < RING_PARTICLE_COUNT_MAX);
		ma_ring_particles[i].m_position = A_CLUMP_CENTER[i % 2] +
		                                  Vector3::getRandomSphereVector() * RING_CLUMP_RADIUS;
		double radius1 = random2(RING_PARTICLE_SIZE_MIN, RING_PARTICLE_SIZE_MAX);
		double radius2 = random2(RING_PARTICLE_SIZE_MIN, RING_PARTICLE_SIZE_MAX);
		if(radius1 < radius2)
			ma_ring_particles[i].m_radius = radius1;
		else
			ma_ring_particles[i].m_radius = radius2;
	}

	assert(invariant());
}
Example #12
0
void shotgun::shot()
{
    if(!pressed && time <= 0 && ammo.x)
    {
        for(int i = 0; i <= 6; i++)
        {
            vec2f r = random2();
            level::makeShot(owner->getPos(), owner->getAngle()+3.1415+r.x*0.2, speed, 0.2+r.y*.1, damage);
        }
        if(!(--ammo.x))
            _reload = reloadTime;
    }
    pressed = 2;
}
Example #13
0
void Splinter::init(const Asteroid &parent, float fi)
{
    _rr = parent.R() /2.;
	x = parent.X() + parent.R() * cos(fi);
	y = parent.Y() + parent.R() * sin(fi);
    _rotateSpeed = parent.rotateSpeed();
    float dv = 0.05;
	vx = parent.VX() + dv *  cos(fi);
    vy = parent.VY() + dv *  sin(fi);
	_color = parent.color();
	angle = atan2(vx, vy);
    nvertices = random2().irandom(12,16);
    _colorMult = parent.colorMult();
    applyParams();
}
Example #14
0
Controller::Controller(int width, int height, int palSize, string device, 
    int* baseColors, int numBaseColors, int baseColorsPerPalette,
    bool layoutLeftToRight, string startDrawerName,
    int drawerChangeInterval, Camera* camera, FaceDetect* faceDetect)
: m_width(width), m_height(height), m_palSize(palSize), m_device(device),
  m_layoutLeftToRight(layoutLeftToRight),
  m_startDrawerName(startDrawerName), 
  m_palettes(palSize, baseColors, numBaseColors, baseColorsPerPalette),
  m_serial(device), m_camera(camera), m_faceDetect(faceDetect),
  m_currDrawer(NULL), m_drawerChangeTimer(drawerChangeInterval),
  m_fpsCounter(5000, "Controller")
{
    m_currPalIndex = random2() % m_palettes.size();

    m_colIndicesSize = width * height;
    m_colIndices = new int[m_colIndicesSize];
    m_serialWriteBufferSize = width * height * 3 + 1;
    m_serialWriteBuffer = new unsigned char[m_serialWriteBufferSize];
    init();
}
Example #15
0
void Controller::changeDrawer(vector<string> names) {
	string name;
	assert(names.size() > 0);
	if (names.size() == 1)
		name = names[0];
	else
		name = names[random2() % names.size()];

    if (m_drawers.find(name) == m_drawers.end()) {
    	cout << "Invalid drawer name: " << name << endl;
    	return;
    }

    cout << "Changing to drawer: " << name << endl;
    m_currDrawer = m_drawers[name];
    randomizeSettings();
    m_currDrawer->reset();

    m_drawerChangeTimer.reset();
}
Example #16
0
void gamble_perform (int i)
{
  object room = this_object();

  switch (random2(2))
  {
    case 0:
    {
      tell_room (room,"\n□□  坤  签  □□\n");
      res[i] = 0;
      break;
    }
    case 1:
    {
      tell_room (room,"\n□□  乾  签  □□\n");
      res[i] = 1;
      break;
    }
  }
}
Example #17
0
 ////////////////////////////*BARS*///////////////////////////////////////////////
 number()
 {  cleardevice();

  rectangle(500,130,580,150);outtextxy(503,133,"EXIT");

  rectangle(200,100,400,300);

    for(a=100;a<300;a=a+50)
    {
      line(200,a,400,a);
    }
    for(a=200;a<400;a=a+50)
    {
      line(a,100,a,300);
    }
    while(b<=15)
    {
     r=random1();r++;
     h=random2();h++;
     switch(h)
     {
       case 1:x=225;y=125;break;
       case 2:x=225;y=175;break;
       case 3:x=225;y=225;break;
       case 4:x=225;y=275;break;
       case 5:x=275;y=125;break;
       case 6:x=275;y=175;break;
       case 7:x=275;y=225;break;
       case 8:x=275;y=275;break;
       case 9:x=325;y=125;break;
       case 10:x=325;y=175;break;
       case 11:x=325;y=225;break;
       case 12:x=325;y=275;break;
       case 13:x=375;y=125;break;
       case 14:x=375;y=175;break;
       case 15:x=375;y=225;break;
       case 16:x=375;y=275;break;
     }
     if(r==16)
     {
       ex=x;ey=y;
     }
     switch(r)
     {
       case 1: outtextxy(x,y,c1); break;
       case 2: outtextxy(x,y,c2);break;
       case 3: outtextxy(x,y,c3);break;
       case 4: outtextxy(x,y,c4);break;
       case 5: outtextxy(x,y,c5);break;
       case 6: outtextxy(x,y,c6);break;
       case 7: outtextxy(x,y,c7);break;
       case 8: outtextxy(x,y,c8);break;
       case 9: outtextxy(x,y,c9);break;
       case 10: outtextxy(x,y,c10);break;
       case 11: outtextxy(x,y,c11);break;
       case 12: outtextxy(x,y,c12);break;
       case 13: outtextxy(x,y,c13);break;
       case 14: outtextxy(x,y,c14);break;
       case 15: outtextxy(x,y,c15);break;
       case 16: outtextxy(x,y,c16);break;
     }
    b++;
     }
      showmouseptr();
   while(flag==0)
   {
       getmousepos(&button,&x,&y);

	if(button==1&&x>500&&x<580&&y>130&&y<150)exit(0);


 /////////////////main logic//////////////
	if(button==1&&((x>ex-75&&x<ex-25&&y<ey+25&&y>ey-25)||(x>ex-25&&x<ex+25&&y<ey-25&&y>ey-75)||(x>ex+25&&x<ex+75&&y>ey-25&&y<ey+25)||(x>ex-25&&x<ex+25&&y>ey+25&&y<ey+75))&&(x>200&&x<400&&y<300&&y>100))
       {  cx=x-(x%50);cy=y-(y%50);
	  size=imagesize(cx+2,cy+2,cx+48,cy+48);
	  buf=malloc(size);
	  hidemouseptr();
	  getimage(cx+2,cy+2,cx+48,cy+48,buf);
	  putimage(ex-23,ey-23,buf,0);
	  free(buf);
	  setfillstyle(SOLID_FILL,GREEN);
	  bar(cx+2,cy+2,cx+48,cy+48);
	  ex=cx+25;ey=cy+25;
	  showmouseptr();
       }
/////////////////

    }


  return(0);
  }
Example #18
0
/////////////////////////////////////////////////////////
// getforce
//
/////////////////////////////////////////////////////////
void newWave :: getforce(void)
{
    float d;
    int i;
    int j;
    for (i=0; i<gridX; i++)
        for ( j=0;j<gridY; j++)
        {
            force[i][j] =0.0;
        }
    // add (low amplitude) noise to avoid denormalisation.
    // this noise does propagate thrus the all structure.
    force[2][2]= 2e-20 * (double)random2() * (1. / 2147483648.) - 1e-20;

		if (K1 != 0)
	{
		for ( i=1; i<gridX; i++)
			for (int j=1;j<gridY; j++)
			{
				d = K1 * (posit[i][j] - posit[i][j-1]);
				force[i][j] -= d;
				force[i][j-1] += d;


				d = K1 * (posit[i][j] - posit[i-1][j]);
				force[i][j] -= d;
				force[i-1][j] += d;
			}
    }

	if (K2 != 0)
	{
		for ( i=1; i<gridX; i++)
			for (int j=1;j<gridY; j++)
			{
				d = K2 * (posit[i][j] - posit[i-1][j-1]);
				force[i][j] -= d;
				force[i-1][j-1] += d;

			}

		for ( i=0; i<gridX-1; i++)
			for (int j=1;j<gridY; j++)
			{
				d = K2 * (posit[i][j] - posit[i+1][j-1]);
				force[i][j] -= d;
				force[i+1][j-1] += d;
			}
    }

	if (K3 != 0)
	{
		for ( i=1; i<gridX-1; i++)
			for (int j=1;j<gridY-1; j++)
			{
				d = K3 * posit[i][j];
			    force[i][j] -= d;
			}
    }

}
Example #19
0
File: douji.c Project: cosin/XYJ
inherit NPC;

int random2 (int i)
{
  return (random(i)+uptime()) % i;
}

void create()
{
  set_name("¶·¼¦", ({ "dou ji", "ji" }) );
  set("race", "Ò°ÊÞ");
  set("gender", "ÐÛÐÔ");
  set("age", 2);
  set("long", "Ò»Ö»ÐÛôñôñµÄ¶·¼¦¡£\n");
  set("attitude", "friendly");
  set("max_kee",400+random2(2)*100);
  set("max_sen",400+random2(2));
  set("str", 40+random2(2));
  set("spi", 40+random2(2));
  set("cor", 40+random2(2));
  set("con", 40+random2(2));
  set("cor", 40+random2(2));
  set("cps", 40+random2(2));
  set_skill("unarmed", random2(2)+10);
  set_skill("dodge", random2(2)+10);
  set_skill("parry", random2(2)+10);
  set("limbs", ({ "Í·²¿", "ÉíÌå", "β°Í" }) );
  set("verbs", ({ "bite"}) );

  // slow down the douji process.
  set("allow_heal_up",1);
Example #20
0
static int compute_dist(int i,int j, int numvert)
{
  int less, gt;
  if (i<j) {less = i; gt = j;} else {less = j; gt = i;}
  return (random2(less*numvert+gt) % RANGE)+1;
}
Example #21
0
File: hall.c Project: Asiim/Kino
static void randomPlace(char a)
{
  hall[random2(MAX_HALLS)].chair[random2(MAX_ROWS)][random2(MAX_COLUMNS)]=a;
}
int main(int argc, char* argv[])
{
    char* months[] = {"jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"};
    int n_prods, i_month, orderline_id, order_id, prod_id, sales, quan_in_stock;
    char fname[50], line[110];
    char filepath[30];
    char toinputfile[50];
    char output_file[150];
    FILE *FP_orderlines;
    int* pTot_sales;
    int i_Sys_Type = 0;	 //0 for Linux, 1 for Windows        //Added by GSK

    //if (argc < 2)
    //if (argc < 3)    //Changed by GSK
    if (argc < 5)    //Changed by WDB adding n_path n_output_file
    {
        printf("syntax:   ds2_create_inv n_path n_prods n_Sys_Type n_output_file\n");  //Changed by GSK //Changed by WDB
        printf("n_Sys_Type can be 0 (Linux) or 1 (Windows) \n");            //Added by GSK
        exit(-1);
    }
    strcpy(filepath,argv[1]); //added by WDB
    n_prods = atoi(argv[2]);
    i_Sys_Type = atoi(argv[3]);	//Added by GSK
    strcpy(output_file,argv[4]); //Added by WDB

    char* pch;
    pch = strstr(output_file,".csv");

    if(pch == NULL)//if the string doesn't end in .csv
    {
        if(( '/' != output_file[ strlen(output_file) - 1 ] ) && ( '\\' != output_file[ strlen(output_file) - 1 ] ))//if the string doesn't end in a backslash
        {
            strcat(output_file,"/inv.csv");
        }
        else
        {
            strcat(output_file,"inv.csv");
        }
    }
    if(( '/' != filepath[ strlen(filepath) - 1 ] ) && ( '\\' != filepath[ strlen(filepath) - 1 ] ))//if the string doesn't end in a backslash
    {
        strcat(filepath,"\\");
    }

    pTot_sales = (int *) calloc(n_prods, sizeof(int));
    if (pTot_sales == NULL)
    {
        printf("Not enough memory\n");
        exit(-1);
    }

    for (prod_id=0; prod_id<n_prods; prod_id++) pTot_sales[prod_id] = 0;

    for (i_month=0; i_month<12; i_month++)
    {
        strcpy(toinputfile,filepath);
        strcat(toinputfile,months[i_month]);
        sprintf(fname, "%s_orderlines.csv", toinputfile);
        if((FP_orderlines = fopen(fname, "r"))==NULL)
        {
            printf("file open error");
            break;
        }

        while(fgets(line, 100, FP_orderlines))
        {
            sscanf(line, "%d,%d,%d,%d", &orderline_id, &order_id, &prod_id, &sales);
            pTot_sales[prod_id-1] += sales;
        }
        fclose(FP_orderlines);
    }
    srand(n_prods); //Seed rand() with n_prods

    {
        FILE *fp;
        fp=fopen(output_file, "w+");

        for (prod_id=0; prod_id<n_prods; prod_id++)
        {
            quan_in_stock = random2(0,500);
            if ((prod_id+1) % 10000 == 0) quan_in_stock *= 10; // boost inventory for hot sellers

            //Changed by GSK
            //Changed by WDB
            //commented out for now since it follows the same code path for both linux and windows
            //this is only valid if you are compiling this on windows with GCC
            //I will make a valid change for both windows and linux if you want to compile this on linux.
            fprintf(fp,"%d,%d,%d\n", prod_id+1, quan_in_stock, pTot_sales[prod_id]);
            // if(i_Sys_Type == 0) //If System type is Linux, Append LF only   //Added by GSK
            // {
            // fprintf(fp,"%d,%d,%d\n", prod_id+1, quan_in_stock, pTot_sales[prod_id]);
            // }
            // else if(i_Sys_Type == 1) //If System type is Windows, Append CR + LF both   //Added by GSK
            // {
            // fprintf(fp,"%d,%d,%d\r\n", prod_id+1, quan_in_stock, pTot_sales[prod_id]);
            // }
        }// end for
        fclose(fp);
    }// end write file
}
Example #23
0
int main (int __argc, char *__argv[])
{
  peo :: init( __argc, __argv );
  if (getNodeRank()==1)
    std::cout<<"\n\nTest : PSO Global Best\n\n";
  rng.reseed (10);
  RingTopology topologyMig;
  eoGenContinue < Indi > genContPara (10);
  eoCombinedContinue <Indi> continuatorPara (genContPara);
  eoCheckPoint<Indi> checkpoint(continuatorPara);
  peoEvalFunc<Indi, double, const Indi& > plainEval(f);
  peoPopEval< Indi > eval(plainEval);
  eoUniformGenerator < double >uGen (0, 1.);
  eoInitFixedLength < Indi > random (2, uGen);
  eoUniformGenerator < double >sGen (-1., 1.);
  eoVelocityInitFixedLength < Indi > veloRandom (2, sGen);
  eoFirstIsBestInit < Indi > localInit;
  eoRealVectorBounds bndsFlight(2,0,1.);
  eoStandardFlight < Indi > flight(bndsFlight);
  eoPop < Indi > pop;
  pop.append (10, random);
  eoLinearTopology<Indi> topology(2);
  eoRealVectorBounds bnds(2,-1.,1.);
  eoStandardVelocity < Indi > velocity (topology,1,0.5,2.,bnds);
  eoInitializer <Indi> init(eval,veloRandom,localInit,topology,pop);
  eoPeriodicContinue< Indi > mig_cont( 2 );
  peoPSOSelect<Indi> mig_selec(topology);
  peoGlobalBestVelocity<Indi> mig_replac (2.,velocity);
  eoContinuator<Indi> cont(mig_cont, pop);
  eoSelector <Indi, eoPop<Indi> > mig_select (mig_selec,1,pop);
  eoReplace <Indi, eoPop<Indi> > mig_replace (mig_replac,pop);
  eoGenContinue < Indi > genContPara2 (10);
  eoCombinedContinue <Indi> continuatorPara2 (genContPara2);
  eoCheckPoint<Indi> checkpoint2(continuatorPara2);
  peoEvalFunc<Indi, double, const Indi& > plainEval2(f);
  peoPopEval< Indi > eval2(plainEval2);
  eoUniformGenerator < double >uGen2 (0, 1.);
  eoInitFixedLength < Indi > random2 (2, uGen2);
  eoUniformGenerator < double >sGen2 (-1., 1.);
  eoVelocityInitFixedLength < Indi > veloRandom2 (2, sGen2);
  eoFirstIsBestInit < Indi > localInit2;
  eoRealVectorBounds bndsFlight2(2,0,1.);
  eoStandardFlight < Indi > flight2(bndsFlight2);
  eoPop < Indi > pop2;
  pop2.append (10, random2);
  eoLinearTopology<Indi> topology2(2);
  eoRealVectorBounds bnds2(2,-1.,1.);
  eoStandardVelocity < Indi > velocity2 (topology2,1,0.5,2.,bnds2);
  eoInitializer <Indi> init2(eval2,veloRandom2,localInit2,topology2,pop2);
  eoPeriodicContinue< Indi > mig_cont2( 2 );
  peoPSOSelect<Indi> mig_selec2(topology2);
  peoGlobalBestVelocity<Indi> mig_replac2 (2.,velocity2);
  eoContinuator<Indi> cont2(mig_cont2,pop2);
  eoSelector <Indi, eoPop<Indi> > mig_select2 (mig_selec2,1,pop2);
  eoReplace <Indi, eoPop<Indi> > mig_replace2 (mig_replac2,pop2);
  peoAsyncIslandMig< eoPop<Indi>, eoPop<Indi> > mig(cont,mig_select, mig_replace, topologyMig);
  checkpoint.add( mig );
  peoAsyncIslandMig< eoPop<Indi>, eoPop<Indi> > mig2(cont2,mig_select2, mig_replace2, topologyMig);
  checkpoint2.add( mig2 );
  eoSyncEasyPSO <Indi> psa(init,checkpoint,eval, velocity, flight);
  peoWrapper parallelPSO( psa, pop);
  eval.setOwner(parallelPSO);
  mig.setOwner(parallelPSO);
  eoSyncEasyPSO <Indi> psa2(init2,checkpoint2,eval2, velocity2, flight2);
  peoWrapper parallelPSO2( psa2, pop2);
  eval2.setOwner(parallelPSO2);
  mig2.setOwner(parallelPSO2);
  peo :: run();
  peo :: finalize();
  if (getNodeRank()==1)
    {
      pop.sort();
      pop2.sort();
      std::cout << "Final population :\n" << pop << std::endl;
      std::cout << "Final population :\n" << pop2	 << std::endl;
    }
}