遗传算法求 f1(x) = x*sin(x)+1， x [0，2π]，求解f1 (x)的最大值和最小值；

最新推荐文章于 2022-04-21 15:17:31 发布

周艾圆

最新推荐文章于 2022-04-21 15:17:31 发布

阅读量2.2k

点赞数 2

分类专栏：算法

本文链接：https://blog.csdn.net/sillyclown/article/details/104185944

版权

算法专栏收录该内容

5 篇文章 1 订阅

订阅专栏

实验内容Experimental Contents ：

设计编码方式和解码方式、设置种群大小、设计适应度函数、结束条件；
编码实现选择、交叉、变异算子，完成轮盘赌方法 (roulette wheel model) 的程序实现，设置合理的选择、交叉、变异概率；

class Main

package com.tylg.EA;

public class Main {

	public final static int GROUPSIZE = 20; // 种群数目
	public final static int ITERATION = 1000; // 迭代次数
	public final static double ACCURACY = 0.000001; // 十进制的精准度（小数点后几位）
	public final static double MP = 0.2; // 变异概率

	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		Code code = new Code();
		Encoding ec = new Encoding();
		Fitness fi = new Fitness();
		Choose choose = new Choose();
		Cross cross = new Cross();
		Mutation mu = new Mutation();

		int bit = code.weiShu(ACCURACY); // 二进制染色体的位数
		String[] genes = ec.initAll(bit, GROUPSIZE * 2);

		// 初始样本种群（二进制形式）
		System.out.println("初始样本种群如下（个数为" + GROUPSIZE * 2 + "）：");
		for (String string : genes) {
			System.out.print("二进制编码为：" + string);
			System.out.print(" ~对应0~2Π上的十进制数大小为：");
			double v = code.deCode(string, bit); // 产生的这个二进制数转化为0~3.1415的十进制数
			System.out.println(v);
		}

		// 把样本种群从二进制变为十进制----通过此方法可以打印输出初始种群的范围值（0 ~ 2PI）~~~~~~~~~调试使用（查看输出）
		double[] dec = new double[GROUPSIZE * 2];
		for (int i = 0; i < GROUPSIZE * 2; i++) {
			double v = code.deCode(genes[i], bit);
			dec[i] = v;
		}

		/*
		 * 迭代运算 ~~~~进行选择，交叉，变异操作，分别调用各个类进行操作
		 */
		String[] newgenes1 = new String[GROUPSIZE];
		String[] newgenes2 = new String[GROUPSIZE * 2];
		// String[] newgenes3 = new String[GROUPSIZE];
		int I = 0;
		while (I < ITERATION) {
			newgenes1 = choose.choose(genes, ACCURACY, GROUPSIZE);
			newgenes2 = cross.cross(newgenes1, GROUPSIZE, ACCURACY);
			genes = mu.mutation(newgenes2, MP, GROUPSIZE, ACCURACY);
			I++;
		}
		// 通过查看最后newgenes里的染色体 ，选择适应度最好的作为返回值即可
		System.out.println("相关参数如下：");
		System.out.println("种群大小为：" + GROUPSIZE + "个，十进制数的精度为：" + ACCURACY + ",交叉概率为0.5" + "，变异概率大小为" + MP);
		System.out.println("经过遗传算法对参数的调整，在经过第" + ITERATION + "次迭代后，得出了最后种群的样本：");

		for (String string : newgenes1) {
			System.out.print("二进制编码为：" + string);
			System.out.print(" ~对应0~2Π上的十进制数大小为：");
			double v = code.deCode(string, bit); // 产生的这个二进制数转化为0~2PI的十进制数
			System.out.println(v);
			double f = fi.fitness(v); // f表示适应度大小
			System.out.println("， 因此xsin(x)+1的函数值在 0 ~ 2Π 上的最大值为：" + f);
			System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

		}
		long end = System.currentTimeMillis();
		System.out.println("程序运行时间为" + (end - start));
	}

}

class Code

package com.tylg.EA;

/*
 * 间接二进制码全部为正数，在此定义域为：0~2PI，码的位数就是m+1
 */
public class Code {


	/*
	 * 码的位数公式，传入的d为精度（例如：0.00001），输出的为二进制码的位数 m(需要m位才能将该数表示出来)
	 */
	public int weiShu(double d) {

		double x = Math.PI / d;
		int m = 0;
		while (true) {
			double low = Math.pow(2, m);
			double high = Math.pow(2, m + 1);
			if ((low < x) && (!(x > high))) {
				return m + 1;
			} else {
				m++;
			}
		}
	}
	
	
	/*
	 * 解码公式, 其中s为某一个基因的二进制编码字符串，m为位数
	 */
	public double deCode(String s, int m) {
		double value = 0;
		int x = Integer.parseUnsignedInt(s, 2);      // 将二进制数的字符串s变为一个2进制的无符号十进制整数
		value = (2 * Math.PI / (Math.pow(2, m) - 1)) * x; // 利用一定的比例此，把一个范围很大十进制数转化为一个范围在0~2PI之间的数
		return value;
	}
	
}

##class Encoding

package com.tylg.EA;

public class Encoding {

	/*
	 * 初始化一条染色体,gene表示染色体的长度，即二进制码的位数
	 */
	public String initSingle(int lengthOfGene) {
		String res = "";
		StringBuilder sb = new StringBuilder(res);
		for (int i = 0; i < lengthOfGene; i++) {
			if (Math.random() < 0.5) {
				sb.append("0");
			}	else {
				sb.append("1");
			}
		}
		return "" + sb;
	}
	
	
	/*
	 * 初始化一组染色体-----（调用初始化一条染色体函数）lengthOfGene表示染色体的长度，即二进制码的位数，groupsize即为种群个数
	 */
	public String[] initAll(int lengthOfGene, int groupSize) {
		
		String[] initall = new String[groupSize];
		for (int i = 0; i < groupSize; i++) {
			initall[i] = initSingle(lengthOfGene);
		}
		return initall; // 该数组当中包含多个字符串，即包含多条（groupSize）染色体
	}
}

class Choose

package com.tylg.EA;

public class Choose {

	/*
	 * 传入一个二进制数组，通过该函数返回一个选择之后的数组
	 */
	public String[] choose(String[] genes, double ACCURACY, int GROUPSIZE) {
		Code code = new Code();
		Fitness fi = new Fitness();
		int bit = code.weiShu(ACCURACY); // bit为二进制染色体的位数

		// 未经选择的种群（二进制形式）
		double fAll = 0;
		for (String string : genes) {
			double v = code.deCode(string, bit); // 产生的这个二进制数转化为0~2PI的十进制数
			fAll += fi.fitness(v);
		}

		// 把种群从二进制变为十进制后,再计算出各自的适应度值
		double[] fArr = new double[GROUPSIZE * 2];
		for (int i = 0; i < GROUPSIZE * 2; i++) {
			double v = code.deCode(genes[i], bit);
			fArr[i] = fi.fitness(v); // 适应度数组
		}

		// 通过下列的for循环，可以得到一个适应度大小从高到低排序的genes染色体数组
		for (int i = 0; i < GROUPSIZE * 2 - 1; i++) {
			for (int j = i + 1; j < GROUPSIZE * 2; j++) {
				if (fArr[i] < fArr[j]) {
					double c1 = fArr[i];
					fArr[i] = fArr[j];
					fArr[j] = c1;
					// 让适应度数组的变化同步至二进制字符串染色体的变化，该做法可让染色体中的基因也是按照一定大小排序
					String c2 = genes[i];
					genes[i] = genes[j];
					genes[j] = c2;
				}
			}
		}


		/*
		 * 计算出每个染色体的相对适应度，即( fc[i] = fArr[i] / fAll ),且fc数组中存放的相对适应度从高到低排序的值
		 */
		double[] fc = new double[GROUPSIZE * 2];
		for (int i = 0; i < GROUPSIZE * 2; i++) {
			fc[i] = fArr[i] / fAll;
		}
		
		/*
		 * 轮盘赌---- 可得到一组新的newgenes[]染色体数组
		 */
		String[] newgenes = new String[GROUPSIZE];
		for (int i = 0; i < GROUPSIZE; i++) {                // 扔骰子次数为GROUPSIZE次
			double dice = Math.random();
			double chip1 = 0.0, chip2 = fc[0];
			for (int j = 0; j < GROUPSIZE * 2; j++) {        // 骰子的值dice与从高到底进行排序的适应度值相比较，
				if ((chip1 < dice || chip1 == dice) && (dice < chip2)) {
					newgenes[i] = genes[j];
					break;
				} else {
					chip1 = chip2;
					chip2 += fc[j + 1];
				}
			}
		}
		return newgenes;
	}

}

class Cross

package com.tylg.EA;

/*
 *  step1：先通过遍历数组的方式，在每次遍历中用随机函数生成一个0~1范围大小的数，再判断交叉概率值cp与其的大小。
 *  step2：若被选中则与其另外一染色体进行中点交叉，适用字符串交换方法
 *  step3：把交叉后的数组与原来传入的数组genes数组进行适应度比较，选择其中适应度排名前GROUPSIZE个数组，作为新的染色体
 *  	      以便执行之后的变异操作
 * 
 */
public class Cross {

	Code code = new Code();
	Fitness fitness = new Fitness();

	public String[] cross(String[] genes, int GROUPSIZE, double ACCURACY) {

		int bit = code.weiShu(ACCURACY); // 二进制染色体的位数
		String[] genes1 = new String[GROUPSIZE];
		String[] genes2 = new String[GROUPSIZE];

		int c1 = 0, c2 = 0;
		for (int i = 0; i < GROUPSIZE; i++) { // for循环就是让genes1与genes2中各分得若干个基因，但其基因总和数为GROUPSIZE个
			double x = Math.random(); // c1 , c2中记录的值就是genes1 与 genes2各自的实际长度
			if (x < 0.5) { // 0.5为选择的交叉概率，就是说有一半的可能性会发生交叉行为
				genes1[c1] = genes[i];
				c1++;
			} else {
				genes2[c2] = genes[i];
				c2++;
			}
		}

		// 对genes1或者genes2中的基因进行交叉操作
		if (c1 % 2 == 0) { // if else语句就是选择一个染色体数组内染色体个数为一半染色体长度（或者一般少一个）的进行交叉~~~该位置的代码有待优化
			int x1 = c1;
			for (int i = 0; i < (x1 / 2); i++) {
				genes1[i] = genes1[i].substring(0, bit / 2) + genes1[x1 - 1 - i].substring(bit / 2, bit);
				genes1[x1 - 1 - i] = genes1[i].substring(bit / 2, bit) + genes1[x1 - 1 - i].substring(0, bit / 2);
			}
		} else {
			int x1 = c2;
			for (int i = 0; i < (x1 / 2); i++) {
				genes2[i] = genes2[i].substring(0, bit / 2) + genes2[x1 - 1 - i].substring(bit / 2, bit);
				genes2[x1 - 1 - i] = genes2[i].substring(bit / 2, bit) + genes2[x1 - 1 - i].substring(0, bit / 2);
			}
		}
		String[] genes12 = new String[GROUPSIZE]; // 新串genes12就是把经过交叉操作后的genes1与genes2连接在一块，其中genes1为被选择中的交叉对象，genes2为没被概率选中对象
		for (int i = 0; i < c1; i++) {
			genes12[i] = genes1[i];
		}
		for (int j1 = 0; j1 < c2; j1++) {
			genes12[j1 + c1] = genes2[j1];
		}

		
		/*
		 * 到目前为止，新的基因数组已经产生，他们是genes1与genes2的组合genes12，总数为GROUPSIZE个，
		 * 需要和他们的父本母本的染色体genes一起进行一个总基因为GROUPSIZE*2个的排序，排序的原则还是按照各自的适应度大小进行排序
		 */
		String[] tgenes = new String[GROUPSIZE * 2];

		for (int i1 = 0; i1 < GROUPSIZE; i1++) {
			tgenes[i1] = genes[i1];
		}
		for (int j1 = 0; j1 < GROUPSIZE; j1++){
			tgenes[j1 + GROUPSIZE] = genes12[j1];
		}
		
		
		/*
		 * 对新的染色体数组tgenes进行排序，排序规则就是适应度大的排在前面，适应度小的排在后面
		 */
		Code code = new Code();
		for (int m = 0; m < GROUPSIZE * 2 - 1; m++) {
			for (int n = m + 1; n < GROUPSIZE * 2; n++) {
				if (fitness.fitness(code.deCode(tgenes[m], bit)) < fitness.fitness(code.deCode(tgenes[n], bit))) {
					String ch = tgenes[m];
					tgenes[m] = tgenes[n];
					tgenes[n] = ch;
				}
			}
		}
		String[] newgenes2 = new String[GROUPSIZE * 2];
		for (int j1 = 0; j1 < GROUPSIZE * 2; j1++) {
			newgenes2[j1] = tgenes[j1];
		}

		return newgenes2;

	}
}

class Mutation

package com.tylg.EA;

public class Mutation {

	/*
	 * 对染色体进行变异操作，步骤如下：
	 * （1）利用random函数随机生成一个数，利用该数与变异概率进行比较，若该数小于或者等于MP，则选择这个基因作为变异基因
	 * （2）对被选择的这个变异基因进行变异操作，操作手法为利用random函数随机生成一个 （1~基因长度）数，并对该位进行取反操作
	 * （3）最后返回该变异过后的数组
	 */	
	public String[] mutation(String[] genes, double MP, int GROUPSIZE, double d) {
		
		Code code = new Code();
		int lensingle = code.weiShu(d); // 单个染色体的长度为lensingle
		
		for (int i = 0; i < GROUPSIZE * 2; i++) {
			double x = Math.random();
			if (x < MP || x == MP) {
				String str = genes[i];
				int c = (int) (lensingle * Math.random()); // 随机获得一个染色体上的某一位
				// 对该位上的0或1进行取反操作
				String newstr = "";
				if (str.charAt(c) == '0') {
					// String newstr = ""; //该newstr中存放的是进行过变异操作后的那个基因
					for (int j = 0; j < lensingle; j++) {
						if (j == c) {
							newstr += '1';
						} else {
							newstr += str.charAt(j);
						}
					}

				} else {
					newstr = "";
					c = (int) (lensingle * Math.random());
					for (int j1 = 0; j1 < lensingle; j1++) {
						if (j1 == c) {
							newstr += '0';
						} else {
							newstr += str.charAt(j1);
						}
					}
					// 现将newstr 替换掉原染色体字符数组中本该进行变异那个基因字符串
					genes[i] = newstr;
				}

			}

		}
		return genes;
	}
}

class Fitness

package com.tylg.EA;

/*
 * 计算单个个体的适应度，输入为一个0~2PI之间的值,返回的为f就是适应度高的，返回的为-f就为适应度低的
 */
public class Fitness {
	public double fitness(double x)	{
		double f = 0;
		f = x * Math.sin(x) + 1;
		return f;
	}
}

求最大值的运行结果是：
初始样本种群如下（个数为40）：
二进制编码为：0100110001111100101010 _对应02Π上的十进制数大小为：1.8772723539324137
二进制编码为：0000100111101101110111 _对应02Π上的十进制数大小为：0.2436977735243896
二进制编码为：0000101011000001010000 _对应02Π上的十进制数大小为：0.2639646006994489
二进制编码为：0100000101111000110100 _对应02Π上的十进制数大小为：1.6069231558924295
二进制编码为：0110110111000010001101 _对应02Π上的十进制数大小为：2.693882127762692
二进制编码为：1011111000001111101010 _对应02Π上的十进制数大小为：4.6648037315176225
二进制编码为：0000001011001100000100 _对应02Π上的十进制数大小为：0.06865164873816366
二进制编码为：1101011110001001101111 _对应02Π上的十进制数大小为：5.29010028940239
二进制编码为：1110110010000000111101 _对应02Π上的十进制数大小为：5.804676065016789
二进制编码为：1010001110100101000110 _对应02Π上的十进制数大小为：4.016451017446046
二进制编码为：1011111101000011100100 _对应02Π上的十进制数大小为：4.694323880553894
二进制编码为：0001111100100100010011 _对应02Π上的十进制数大小为：0.7643345723297336
二进制编码为：0100110111101011110000 _对应02Π上的十进制数大小为：1.9124670348142854
二进制编码为：0110101101101101010001 _对应02Π上的十进制数大小为：2.6366514480823042
二进制编码为：0001010010111101111110 _对应02Π上的十进制数大小为：0.5090869992991198
二进制编码为：0100011000001011101111 _对应02Π上的十进制数大小为：1.7191839114302938
二进制编码为：1001010011111100000000 _对应02Π上的十进制数大小为：3.6566275749303476
二进制编码为：1110011000001001000101 _对应02Π上的十进制数大小为：5.645920999845373
二进制编码为：1100001000000110011011 _对应02Π上的十进制数大小为：4.762093190523035
二进制编码为：0110111110001011101011 _对应02Π上的十进制数大小为：2.737741405316937
二进制编码为：1101000010111000010011 _对应02Π上的十进制数大小为：5.122758525039058
二进制编码为：0100100010010100111100 _对应02Π上的十进制数大小为：1.7814254963439264
二进制编码为：0000100100101100111110 _对应02Π上的十进制数大小为：0.22520461205819797
二进制编码为：1010011010110101100001 _对应02Π上的十进制数大小为：4.091656540741893
二进制编码为：0110110010000100000100 _对应02Π上的十进制数大小为：2.663380770078356
二进制编码为：0001100110001000100000 _对应02Π上的十进制数大小为：0.6266792381628793
二进制编码为：1001000111001100011101 _对应02Π上的十进制数大小为：3.5784379789216096
二进制编码为：1110101001111101011110 _对应02Π上的十进制数大小为：5.755254607752218
二进制编码为：0110101010010101001100 _对应02Π上的十进制数大小为：2.615935212366147
二进制编码为：1100101101010101111100 _对应02Π上的十进制数大小为：4.990609943529127
二进制编码为：0100011000101010000010 _对应02Π上的十进制数大小为：1.7220885886342585
二进制编码为：0001100001000011101000 _对应02Π上的十进制数大小为：0.5955322302078322
二进制编码为：1110100111100110001111 _对应02Π上的十进制数大小为：5.740755190187919
二进制编码为：1101011101000110001000 _对应02Π上的十进制数大小为：5.283618320211283
二进制编码为：1001100101100011100000 _对应02Π上的十进制数大小为：3.7647253093491724
二进制编码为：0101010010001101001010 _对应02Π上的十进制数大小为：2.075203859659831
二进制编码为：0001001011001010001001 _对应02Π上的十进制数大小为：0.4611665665618169
二进制编码为：1010001100000101111011 _对应02Π上的十进制数大小为：4.001190601418822
二进制编码为：0101110110000101110011 _对应02Π上的十进制数大小为：2.295391574370903
二进制编码为：0101001011110110100100 _对应02Π上的十进制数大小为：2.0362221628049717
相关参数如下：
种群大小为：20个，十进制数的精度为：1.0E-6,交叉概率为0.5，变异概率大小为0.2
经过遗传算法对参数的调整，在经过第1000次迭代后，得出了最后种群的样本：
二进制编码为：0101000000001010000000 _对应02Π上的十进制数大小为：1.9644546148485271
，因此xsin(x)+1的函数值在 0 ~ 2Π 上的最大值为：2.814197479352538

二进制编码为：0101000000001010000000 ~对应0~2Π上的十进制数大小为：1.9644546148485271
， 因此xsin(x)+1的函数值在 0 ~ 2Π 上的最大值为：2.814197479352538