博客

package test1;

import java.util.Arrays;

//粒子群算法
public class PSO {

	static double f(double[] x) {
		double summ=0;
		for(double e:x) {
			summ=summ+Math.pow(e, 2);//目标函数，这里是寻找最小值
		}
		return summ;
		
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int N,D,G,i,j;
		double c1,c2,w,w_max,w_min,Xmax,Xmin,Vmax,Vmin;
		N=100;D=10;G=5000;c1=2;c2=2;w=1.5;w_max=1.5;w_min=0.1;
		Xmax=20;Xmin=-20;Vmax=0.00001;Vmin=-0.00001;
		double[][] X=new double[N][D];
		//初始化种群，与对应的速度
		for(i=1;i<=N;i+=1) {
			for(j=1;j<=D;j+=1) {
				X[i-1][j-1]=Math.random()*(Xmax-Xmin)+Xmin;
			}
		}
		
		double[][] V=new double[N][D];
		for(i=1;i<=N;i+=1) {
			for(j=1;j<=D;j+=1) {
				V[i-1][j-1]=Math.random()*(Vmax-Vmin)+Vmin;
			}
		}
		
		double[][] p=new double[N][D];
		p=X;
		double[] p_best=new double[N];
		for(i=1;i<=N;i+=1) {
			p_best[i-1]=f(X[i-1]);
			//计算每一组自变量对应的目标函数值
		}

		double p_best_min=Arrays.stream(p_best).min().getAsDouble();
		int index = 0;
		for(i=0;i<N;i+=1) {
			if(p_best_min==p_best[i]) {
				index=i;//确定最优值，对应的索引			
			}
		}
		double g_best=p_best_min;
		double[] g=X[index];//根据索引返回最优值所对应的自变量组
		double[] gb=new double[G];
		//粒子群算法开始迭代
		for(i=0;i<G;i+=1) {
			for(j=0;j<N;j+=1) {
				double X0=f(X[j]);
				double d_p=X0-p_best[j];//看看当前第j个与p_best哪个好
				if(d_p<0) {     //小于0 ，则说明当前个体X0更优
					p_best[j]=X0;//将更好的X0替换掉p_best之前的
					p[j]=X[j];//同时将最好的X0对应自变量提取出来，放到p里面储存
				}
				double d_g=p_best[j]-g_best;//看看当前第j个个体最优值与群体最优值哪个好
				if(d_g<0) {
					g_best=p_best[j];
					//将更好的p_best赋值到g_best,替换之前的，作为新的群体最优值
					g=p[j];//同时将p_best对应自变量提取出来，放到g里储存
				}
				double w_V,p_X,g_X,M_rand1,M_rand2;
				M_rand1=Math.random();M_rand2=Math.random();
				for(int k=0;k<D;k+=1) {
					w_V=w*V[j][k];
					p_X=p[j][k]-X[j][k];
					g_X=g[k]-X[j][k];
					V[j][k]=w_V+c1*M_rand1*(p_X)+c2*M_rand2*(g_X);
					X[j][k]=X[j][k]+V[j][k];
				}
				//以上为粒子群算法核心公式，
				
				//判断是否有值超出了边界，超出则拉回
				for(int ii=0;ii<D;ii+=1) {
					if((V[j][ii]>Vmax)||(V[j][ii]<Vmin)) {
						V[j][ii]=Math.random()*(Vmax-Vmin)+Vmin;
					}
					if((X[j][ii]>Xmax)||(X[j][ii]<Xmin)) {
						X[j][ii]=Math.random()*(Xmax-Xmin)+Xmin;
					}
				}
			}
			gb[i]=g_best;//将每次迭代的最优值储存起来
		
			w=(w_max-w_min)*(G-i)/G+w_min;//随着迭代增加动态调整惯性权重
			//if(i%1000==0) {
				//Vmax=Vmax*10;
				//Vmin=Vmin*10;	
			//}
		}
		
		System.out.println(String.format("%.2f", g_best));
		System.out.println("最小值为"+g_best);
		
	}

}

运行结果：

0.00

最小值为1.8601804912955194E-10