spso.c

智能仿生算法PSO算法的源代码

#include"stdio.h"
#include"stdlib.h"
#include"time.h"
#include"math.h"

#define POPSIZE 100
#define DIMENSION 30
#define RUN_TIME 10
#define MAX_LENGTH 1000
#define PI 3.1415926

double W=1.0;
double C1=2.0;
double C2=2.0;
double VMAX=10.0;
double XMIN=-100.0;
double XMAX=100.0;
double Total_Best[RUN_TIME];
double Different_point[20][RUN_TIME];

struct indi
{
	double speed[DIMENSION];
	double best[DIMENSION];
	double bestfitness;
	double number[DIMENSION];
	double fitness;
}individual[POPSIZE],global_best;


double rdft(void);
double uniform_distribution(void);
void calculation(int flag);
void initiate(void);
void localbest(int flag);
void globalbest(void);
void statistical_computing(void);
void f1(int flag);
double normal_distribution(void);
void f2(int flag);

void f2(int flag)
{
	int j;
	double s=0.0,h=1.0;
	for(j=0;j<DIMENSION;j++)
	{
		s=s+fabs(individual[flag].number[j]);
		h=h*fabs(individual[flag].number[j]);
	}
	individual[flag].fitness=s+h;
}

double normal_distribution()
{
	double s1,s2,y;
	s1=uniform_distribution();
	s2=uniform_distribution();
	y=sqrt(-2.0*log(s2))*cos(2.0*PI*s1);
	return(y);
}

void f1(int flag)
{
	int j;
	double s=0.0;
	for(j=0;j<DIMENSION;j++)
		s=s+pow(individual[flag].number[j],2.0);
	individual[flag].fitness=s;
}

void statistical_computing()
{
	int i,j;
	double s,sum,ave,std;
	/*the priori solution*/
	printf("\nThe following data is the average data\n");
	for(i=0;i<20;i++)
	{
		sum=0.0;
	    for(j=0;j<RUN_TIME;j++)
			sum=sum+Different_point[i][j];
		ave=sum/RUN_TIME;
		printf("%e\t",ave);
	}
	printf("\n");
	/* the last solution */
	if(RUN_TIME==1)
	{
		sum=Total_Best[0];
		ave=sum;
		std=0.0;
	}
	else
	{
		sum=0.0;
		for(j=0;j<RUN_TIME;j++)
			sum=sum+Total_Best[j];
		ave=sum/RUN_TIME;
		s=0.0;
		for(j=0;j<RUN_TIME;j++)
			s=s+pow(Total_Best[j]-ave,2.0);
		std=sqrt(s/(RUN_TIME-1));
	}
	printf("\n");
	printf("The sum of best solution is %e\n",sum);
	printf("The mean of total runs is %e\n",ave);
	printf("The std value of total runs is %e\n",std);
}

void globalbest()
{
	int i,j;
	for(i=0;i<POPSIZE;i++)
		if(individual[i].bestfitness<global_best.fitness)
		{
			global_best.fitness=individual[i].bestfitness;
			for(j=0;j<DIMENSION;j++)
				global_best.number[j]=individual[i].best[j];
		}
}

void localbest(int flag)
{
	int j;
	if(individual[flag].fitness<individual[flag].bestfitness)
	{
		individual[flag].bestfitness=individual[flag].fitness;
		for(j=0;j<DIMENSION;j++)
			individual[flag].best[j]=individual[flag].number[j];
	}
}

void initiate()
{
	int i,j;
	/*individual initiate() */
	for(i=0;i<POPSIZE;i++)
	{
		for(j=0;j<DIMENSION;j++)
		{
			individual[i].number[j]=XMIN+(XMAX-XMIN)*rdft();
			individual[i].speed[j]=VMAX*rdft();
		}
		calculation(i);
	}
	/* best position of individual */
	for(i=0;i<POPSIZE;i++)
	{
		for(j=0;j<DIMENSION;j++)
			individual[i].best[j]=individual[i].number[j];
		individual[i].bestfitness=individual[i].fitness;
	}
	/* global_best of swarm */
	global_best.fitness=individual[0].bestfitness;
	for(j=0;j<DIMENSION;j++)
		global_best.number[j]=individual[0].best[j];
	for(i=1;i<POPSIZE;i++)
		if(global_best.fitness>individual[i].bestfitness)
		{
			global_best.fitness=individual[i].bestfitness;
			for(j=0;j<DIMENSION;j++)
				global_best.number[j]=individual[i].best[j];
		}
}

void calculation(int num)
{
	f1(num);
}

double rdft()
{
	return(uniform_distribution());
}

double uniform_distribution()
{
	double s;
	s=(double)((double)(rand())/(double)(RAND_MAX));
	return(s);
}

main()
{
	int i,j,k,t,point_flag;
	double sum=0;
	srand(time(NULL));
	for(j=0;j<RUN_TIME;j++)
	{
		initiate();
		point_flag=0;
	    for(i=0;i<MAX_LENGTH;i++)
		{
			/* adaptive coefficients adjusting */
			W=0.9-i*0.5/(MAX_LENGTH-1);
			for(k=0;k<POPSIZE;k++)
			{
					for(t=0;t<DIMENSION;t++)
					{
						individual[k].speed[t]=W*individual[k].speed[t]+C1*rdft()*(individual[k].best[t]-individual[k].number[t])+C2*rdft()*(global_best.number[t]-individual[k].number[t]);
						if(individual[k].speed[t]>VMAX)
							individual[k].speed[t]=VMAX;
						if(individual[k].speed[t]<(-1)*VMAX)
							individual[k].speed[t]=(-1)*VMAX;
						individual[k].number[t]=individual[k].number[t]+individual[k].speed[t];
						if(individual[k].number[t]<XMIN)
							individual[k].number[t]=XMAX-fmod(fabs(individual[k].number[t]),XMAX-XMIN);
						if(individual[k].number[t]>XMAX)
							individual[k].number[t]=XMIN+fmod(fabs(individual[k].number[t]),XMAX-XMIN);
					}
					calculation(k);
					localbest(k);
			}
			globalbest();
			if(fmod(i,75)==0)
			{
				 Different_point[point_flag][j]=global_best.fitness;
				 point_flag++;
			}
		}
		printf("%e\t",global_best.fitness);
		Total_Best[j]=global_best.fitness;
	}
	statistical_computing();
}