/*-------------------------------------------------------------------------*/
/* Program: ppso.c                                                         */
/* This program is parallel particle swarm optimization.                   */
/*-------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define POPSIZE   40    /* Population size *//**********/
#define MAXGENS   2000  /* Maximum number of generations */
#define GA_GAP    20 /**********/
#define GA_GAP2   100
#define GP        4  /**********/
#define BITNO     2
#define NoCopy    20
#define NoCopy2   2
#define NoSeed    50
#define MAXV		100 /* Maximum velocity */
//#define MAXR		100 /* Maximum range */
#define LeftInitR 15  /* left initialization range */
#define RightInitR 30 /* right initialization range */
#define InitWeight 0.9 /* initial inertia weight */
#define FinalWeight 0.4 /* final inertial weight */
#define DIMENSION 30
#define C1 2
#define C2 2


int Generation;   /* Current generation number */
int Best[GP];         /* The best particle for each population */
float GlobalBest[GP]; /* the global best fitness for each population */
float GlobalBestParticle[GP][DIMENSION]; /* the global best path for each population */
float TotalBest;
float TotalBestParticle[DIMENSION];
float weight;

struct genotype           /* Each genotype is a number of the population */
{
  float Particle[DIMENSION]; /* A string of vars makes a genotype, codebook index *//*****/
  float Fitness;         /* The genotype's fitness */
  float BestParticle[DIMENSION];
  float BestParticleFitness; /* the best value for the path of each particle */
  float Velocity[DIMENSION];
};

struct genotype Population[GP][POPSIZE]; /* The population of genotypes */

/* GA function prototypes */
void init(void);
void evaluate(void);
float f6(int,int);
float sphere(int,int,int);
float rosenbrock(int,int,int);
float rastrigrin(int,int,int);
float griewank(int,int,int);
void exchange(void);
void exchange2(void);
void exchange3(void);
void exchange4(void);
void exchange5(void);
void exchange6(void);
void exchange7(void);
void exchange8(void);
void exchange9(void);
void exchange10(void);
void exchange20(void);
void exchange21(void);
void sorting(void);

FILE *fptr;


int main()
{
  int t;
  float calculation=0.0;
  unsigned seed;


//  printf("\nEnter a seed :");
//  scanf("%u",&seed);
if((fptr = fopen("test-ros440.txt","w"))==NULL)
    {
      exit(1);
    }
for(seed=1;seed<NoSeed+1;seed++){
  srand(seed);
  Generation = 0;
//  printf("\nGen=%i",Generation);
  init();
  evaluate();
while(Generation < MAXGENS)
  {
    Generation++;
//    printf("\nGen=%i",Generation);
    evaluate();
    t=Generation % GA_GAP2;
    if(t == 0){
      exchange20();}
    t=Generation % GA_GAP;
    if(t == 0){
      exchange21();}
  }
  fprintf(fptr,"Seed=%i,fitness=%f\n",seed,TotalBest);
  calculation=calculation+TotalBest;
}
  calculation=calculation/NoSeed;
  fprintf(fptr,"Avegage=%f\n",calculation);
  fclose(fptr);
  
  return 0;
}
/*---------------------------------------------*/
/* random assign initial population            */
/*---------------------------------------------*/
void init(void)
{
  int i,j,m;
  for(m=0;m<GP;m++){
    for(i=0;i<POPSIZE;i++){
    	for(j=0;j<DIMENSION;j++){
  			Population[m][i].Particle[j]= (float)((rand()%1000)/1000.0)*
  			(RightInitR-LeftInitR)+LeftInitR;
  			Population[m][i].BestParticle[j]=Population[m][i].Particle[j];
  			Population[m][i].Velocity[j]=MAXV*((rand()%1000)/1000.0);
         if(((rand()%1000)/1000.0)>0.5)
         	Population[m][i].Velocity[j]=-Population[m][i].Velocity[j];}}}
  for(m=0;m<GP;m++){
      GlobalBest[m]=9999999999999999.9;
      for(i=0;i<POPSIZE;i++){
      	Population[m][i].BestParticleFitness=999999999999.9;}}
   TotalBest=9999999999999999.9;
}

/*---------------------------------------------*/
/* evaluate fitness                            */
/*---------------------------------------------*/
void evaluate(void)
{ int i,j,m;
  weight=(InitWeight-FinalWeight)*(MAXGENS-Generation)/MAXGENS + FinalWeight;
 // printf("weight=%f",weight);
 // getchar();
  for(m=0;m<GP;m++){
    for(i=0;i<POPSIZE;i++){
    	Population[m][i].Fitness= rosenbrock(m, i, DIMENSION);  /***************/

      if ( Population[m][i].Fitness < Population[m][i].BestParticleFitness){
         Population[m][i].BestParticleFitness= Population[m][i].Fitness;

         for (j=0;j<DIMENSION;j++)
         	Population[m][i].BestParticle[j]= Population[m][i].Particle[j];
         if (Population[m][i].BestParticleFitness < GlobalBest[m]){
         	GlobalBest[m]=Population[m][i].BestParticleFitness;
            for (j=0;j<DIMENSION;j++)
            	GlobalBestParticle[m][j]=Population[m][i].BestParticle[j];
         }
      }

				/* asynchronous version */
      for (j=0;j<DIMENSION;j++){
      	Population[m][i].Velocity[j]=weight*Population[m][i].Velocity[j]
         + C1*((rand()%1000)/1000.0)*(Population[m][i].BestParticle[j]
         - Population[m][i].Particle[j])
         + C2*((rand()%1000)/1000.0)*(GlobalBestParticle[m][j]
         - Population[m][i].Particle[j]);
         if(Population[m][i].Velocity[j]>MAXV)  Population[m][i].Velocity[j]=MAXV;
         else if( Population[m][i].Velocity[j]<-MAXV) Population[m][i].Velocity[j]=-MAXV;
         Population[m][i].Particle[j]=Population[m][i].Particle[j]
         +Population[m][i].Velocity[j];
      }
    }
  }

  for(m=0;m<GP;m++){
    if(GlobalBest[m] <  TotalBest){
    	 TotalBest= GlobalBest[m];
       for (j=0;j<DIMENSION;j++){
       	TotalBestParticle[j]=GlobalBestParticle[m][j];}
    }
  }
//  printf("\n Gen=%i,fitness=%f",Generation,TotalBest);
 // getchar();
}

/*---------------------------------------------*/
/* calculate the value of rosenbrock function  */
/*---------------------------------------------*/
float rosenbrock(int m, int a, int b)
{
	/* this is the Rosenbrock function
		a: index of the particles; b:dimension */
	int i;
	double result;
	result=0.0;
	for (i=1;i<b;i++)
	{
		result +=100.0*(Population[m][a].Particle[i]-Population[m][a].Particle[i-1]
      * Population[m][a].Particle[i-1])
      *(Population[m][a].Particle[i]-Population[m][a].Particle[i-1]
      * Population[m][a].Particle[i-1])
      + (Population[m][a].Particle[i-1]-1)* (Population[m][a].Particle[i-1]-1);
	}
	return (float) result;
}

/*---------------------------------------------*/
/* calculate the value of rosenbrock function  */
/*---------------------------------------------*/
float rastrigrin(int m, int a, int b)
{
   /* This is the generalized Rastrigrin function
		a:index of the particles; b:dimension */

	int i;
	double result;
	result=0.0;
	for (i=0;i<b;i++)
	{
		result +=Population[m][a].Particle[i]*Population[m][a].Particle[i]
			- 10.0*cos(2.0*3.141591*Population[m][a].Particle[i])+10.0;
	}
	return (float)result;
}
/*---------------------------------------------*/
/* calculate the value of rosenbrock function  */
/*---------------------------------------------*/
float griewank(int m, int a, int b)
{
  	/* This is the generalized Griewank function
		a:index of the particles; b:dimension */

	int i;
	double result_s,result_p;

	result_s=0.0;
	result_p=1.0;

	for (i=0;i<b;i++)
	{
		result_s +=Population[m][a].Particle[i]*Population[m][a].Particle[i];
		result_p *=cos(Population[m][a].Particle[i]/sqrt((double)i+1));
	}
	result_s =result_s/4000.0 - result_p +1;

	return (float)result_s;
}

/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange20()
{
  int i,j,m,k,p;
  int bit_map[3]={1,2,4};
  int count[GP];
  for(m=0;m<GP;m++){
  	count[m]=0;}

  sorting();
  for(m=0;m<GP;m++){
    for(k=0;k<BITNO;k++){
      i=m^bit_map[k];
     for(p=0;p<NoCopy2;p++){
      for(j=0;j<DIMENSION;j++){
			Population[i][count[i]].Particle[j]=GlobalBestParticle[m][j];}
      	Population[i][count[i]].Fitness=GlobalBest[m];
         count[i]++;
     }
    }
//    GlobalBest[m]=TotalBest;
//    for (j=0;j<DIMENSION;j++){
//       	GlobalBestParticle[m][j]=TotalBestParticle[j];}
	}
}
/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange21()
{
  int j,m,t,i;
  float q;

  sorting();

  for(m=0;m<GP/2;m++){
  	for(i=0;i<NoCopy;i++){
  //    t = (rand() % POPSIZE);
      for(j=0;j<DIMENSION;j++){
         q = (float)((rand()%1000)/1000.0)*0.02+0.99;
			Population[m][i].Particle[j]=TotalBestParticle[j]*q;}
      Population[m][i].Fitness=TotalBest;
    }

   	GlobalBest[m]=TotalBest;
   	for (j=0;j<DIMENSION;j++){
       	GlobalBestParticle[m][j]=TotalBestParticle[j];}
   }
}

/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange()
{
  int i,j,m,t,k;
  int bit_map[3]={1,2,4};
  for(m=0;m<GP;m++){
    for(k=0;k<BITNO;k++){
      i=m^bit_map[k];
      t = (rand() % POPSIZE);
      for(j=0;j<DIMENSION;j++){
			Population[i][t].Particle[j]=GlobalBestParticle[m][j];}
      	Population[i][t].Fitness=GlobalBest[m];
   }
   GlobalBest[m]=TotalBest;
   for (j=0;j<DIMENSION;j++){
       	GlobalBestParticle[m][j]=TotalBestParticle[j];}
	}
}
/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange9()
{
  int i,j,m,k,p;
  int bit_map[3]={1,2,4};
  int count[GP];
  for(m=0;m<GP;m++){
  	count[m]=0;}

  sorting();
  for(m=0;m<GP;m++){
    for(k=0;k<BITNO;k++){
      i=m^bit_map[k];
     for(p=0;p<NoCopy;p++){
      for(j=0;j<DIMENSION;j++){
			Population[i][count[i]].Particle[j]=GlobalBestParticle[m][j];}
      	Population[i][count[i]].Fitness=GlobalBest[m];
         count[i]++;
     }
    }
//    GlobalBest[m]=TotalBest;
//    for (j=0;j<DIMENSION;j++){
//       	GlobalBestParticle[m][j]=TotalBestParticle[j];}
	}
}

/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange8()
{
  int i,j,m,k;
  int bit_map[3]={1,2,4};
  sorting();
  for(m=0;m<GP;m++){
    for(k=0;k<BITNO;k++){
      i=m^bit_map[k];
      for(j=0;j<DIMENSION;j++){
			Population[i][k].Particle[j]=GlobalBestParticle[m][j];}
      	Population[i][k].Fitness=GlobalBest[m];
    }
//    GlobalBest[m]=TotalBest;
//    for (j=0;j<DIMENSION;j++){
//       	GlobalBestParticle[m][j]=TotalBestParticle[j];}
	}
}
/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange4()
{
  int j,m,t,i;
  for(m=0;m<GP;m++){
  	for(i=0;i<NoCopy;i++){
      t = (rand() % POPSIZE);
      for(j=0;j<DIMENSION;j++){
			Population[m][t].Particle[j]=TotalBestParticle[j];}
      Population[m][t].Fitness=TotalBest;
    }
      
   	GlobalBest[m]=TotalBest;
   	for (j=0;j<DIMENSION;j++){
       	GlobalBestParticle[m][j]=TotalBestParticle[j];}
   }
}
/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange6()
{
  int j,m,t,i;
  float q;
  for(m=0;m<GP;m++){
  	for(i=0;i<NoCopy;i++){
      t = (rand() % POPSIZE);
      for(j=0;j<DIMENSION;j++){
         q = (float)((rand()%1000)/1000.0)*0.02+0.99;
			Population[m][t].Particle[j]=TotalBestParticle[j]*q;}
      Population[m][t].Fitness=TotalBest;
    }

   	GlobalBest[m]=TotalBest;
   	for (j=0;j<DIMENSION;j++){
       	GlobalBestParticle[m][j]=TotalBestParticle[j];}
   }
}
/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange10()
{
  int j,m,t,i;
  float q;

  sorting();

  for(m=0;m<GP;m++){
  	for(i=0;i<NoCopy;i++){
  //    t = (rand() % POPSIZE);
      for(j=0;j<DIMENSION;j++){
         q = (float)((rand()%1000)/1000.0)*0.02+0.99;
			Population[m][i].Particle[j]=TotalBestParticle[j]*q;}
      Population[m][i].Fitness=TotalBest;
    }

   	GlobalBest[m]=TotalBest;
   	for (j=0;j<DIMENSION;j++){
       	GlobalBestParticle[m][j]=TotalBestParticle[j];}
   }
}
/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange7()
{
  int j,m,i;
  float q;
  sorting();
  for(m=0;m<GP;m++){
  	for(i=0;i<NoCopy;i++){
      for(j=0;j<DIMENSION;j++){
         q = (float)((rand()%1000)/1000.0)*0.02+0.99;
			Population[m][i].Particle[j]=TotalBestParticle[j]*q;}
      Population[m][i].Fitness=TotalBest;
    }

   	GlobalBest[m]=TotalBest;
   	for (j=0;j<DIMENSION;j++){
       	GlobalBestParticle[m][j]=TotalBestParticle[j];}
   }
}
/*----------------------------------------------------------------------------*/
/* Sort the individuals                                                       */
/*----------------------------------------------------------------------------*/
void sorting()
{
  int m,i,j,k;
  float temp;
  for(m=0;m<GP;m++){
  	for(i=0;i<POPSIZE;i++){
    for(j=i+1;j<POPSIZE;j++){
      if(Population[m][i].Fitness<Population[m][j].Fitness){
			temp=Population[m][i].Fitness;
			Population[m][i].Fitness=Population[m][j].Fitness;
			Population[m][j].Fitness=temp;

         temp=Population[m][i].BestParticleFitness;
         Population[m][i].BestParticleFitness=Population[m][j].BestParticleFitness;
         Population[m][j].BestParticleFitness=temp;

			for(k=0;k<DIMENSION;k++){
	  			temp=Population[m][i].Particle[k];
	  			Population[m][i].Particle[k]=Population[m][j].Particle[k];
	  			Population[m][j].Particle[k]=temp;

            temp=Population[m][i].BestParticle[k];
            Population[m][i].BestParticle[k]=Population[m][j].BestParticle[k];
            Population[m][j].BestParticle[k]=temp;
         }


       }
      }
    }
   }
}
/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange5()
{
  int j,m,t;
  for(m=0;m<GP;m++){
      t = (rand() % POPSIZE);
      for(j=0;j<DIMENSION;j++){
			Population[m][t].Particle[j]=TotalBestParticle[j];}
      Population[m][t].Fitness=TotalBest;
   }
}
/*----------------------------------------------------------------------------*/
/* Update the TotalBest to each group                                         */
/*----------------------------------------------------------------------------*/
void exchange2()
{
  int j,m;
  for(m=0;m<GP;m++){
   GlobalBest[m]=TotalBest;
   for (j=0;j<DIMENSION;j++){
       	GlobalBestParticle[m][j]=TotalBestParticle[j];}
	}
}
/*----------------------------------------------------------------------------*/
/* Send the best fitness of each group to the other groups                    */
/*----------------------------------------------------------------------------*/
void exchange3()
{
  int i,j,m,t,k;
  int bit_map[3]={1,2,4};
  for(m=0;m<GP;m++){
    for(k=0;k<BITNO;k++){
      i=m^bit_map[k];
      t = (rand() % POPSIZE);
      for(j=0;j<DIMENSION;j++){
			Population[i][t].Particle[j]=GlobalBestParticle[m][j];}
      	Population[i][t].Fitness=GlobalBest[m];
     }
	}
}