一个小题目遗传算法的部分编码

题目：y=x^5-6x^4+14x^3-2x^2+1 x属于1到20

手动计算一下：

x属于0到19
y=(x+1)^5-6(x+1)^4+14(x+1)^3-2(x+1)^2+1
=x^5-x^4+14x^2+19x+7

发现如果是16到19那么变异算法编码就很麻烦了。先不考虑这部分的问题

中文表述：

编码是L=4，依然采用2进制编码，自然数编码太复杂。我不懂。 所以群体规模我还

是取4，关于编码长度和群体规模的取值我查了一下文档，不知道这个怎么办。就按

照《遗传算法群体规模的研究》来看我还是取4.
然后随机取值。还是4个。既然是随机就用随机数生成函数来搞定。我用均匀分布，

然后在区间里面搞定。[0,3][4,7][8,11][12,15]然后四个区间，慢慢取。
下面进入自动的环节。前面全部都是人工干预的。
step1,计算适应度。即
yi=f(xi) 适应度 Y=yi/Εyi
step2,删除最低适应度的，将最高适应度的复制入最低适应度的。(这个就不算除法

了，反正y也是线性的，直接算极大值吧。)
step3,几个位交换x1和x4,x2和x3 0.5~0.8的概率 第一次玩0.65吧。
step4,变异，每个位，都可能变异吧。0.1的概率。
step5,还是长相完全一样就停止。

下面因为是未付费，而且是学术探讨所以具体代码不给出。超过100行和较难的编码一概不公开。

测试案例，后面给出了完备性算法的结果。结果发现最优解是x=3,y=109,而我算来算去都是x=4,y=108也算是差不多了，哪怕开始选择的时候也有x=3。遗传算法果然是非完备性算法。

Code:

1.    package 遗传算法;   

2.      

3.    public class test {   

4.      

5.        /**  

6.         * @param args  

7.         */  

8.        public static void main(String[] args) {   

9.            // TODO Auto-generated method stub   

10.         Genetic gen=new Genetic();   

11.         Fuction fun=new Fuction();   

12.         gen.Geneticmain();   

13.         System.out.println("下面是测试案例");   

14.         for(int i=0;i<15;i++){   

15.             System.out.println("x="+i+";y="+fun.fuctionValue(i));   

16.         }   

17.            

18.     }   

19.   

20. }   

Code:

1.    package 遗传算法;   

2.      

3.    public class Genetic {   

4.        private static final double semaphore = 0.65;   

5.        public int []cx={-1,-1,-1,-1};   

6.        public int []bix={-1,-1,-1,-1};   

7.        public int []cy={0,0,0,0};   

8.        public int ty=0;//total y 没啥用   

9.           

10.        

11.     Fuction fun=new Fuction();//调用   

12.        

13.     //主函数   

14.     public void Geneticmain(){   

15.         //初始化   

16.         init();   

17.         while(true){   

18.         //计算适应度   

19.         for(int i=0;i

20.         cy[i]=fun.fuctionValue(cx[i]);   

21.            

22.         //选取最高值   

23.         maxToMin();   

24.            

25.         //杂交   

26.         swap(bix[0],0,bix[3],3);   

27.         swap(bix[2],2,bix[1],1);   

28.            

29.         //变异   

30.         variaty();   

31.         //判定函数   

32.         if(cx[0]==cx[1]&&cx[2]==cx[3]&&cx[3]==cx[1]) break;   

33.         }   

34.            

35.         //打印结果   

36.         System.out.print("x="+cx[1]+";y="+cy[1]);   

37.     }   

38.     //变异函数   

39.      private void variaty() {   

40.         。。         

41.     }   

42.      //变异   

43.     private void vary(int i, int j) {   

44.         。。         

45.     }   

46.     //是否变异   

47.     private boolean isVary() {   

48.         boolean flag=false;   

49.         if(Math.random()<=0.1) flag=true;   

50.         return flag;   

51.     }   

52.     //杂交函数   

53.     private void swap(int x, int j, int y, int k) {   

54.         。。         

55.     }   

56.     //位交换   

57.     private void swapbit(int x, int y, int i) {   

58.         。。                 

59.                    

60.         }   

61.            

62.     }   

63.     //是否交换   

64.     private boolean isswap() {   

65.                          。。   

66.     }   

67.                      //最大值复制到最小值里面   

68.     void maxToMin(){   

69.          。。        

70.     }   

71.     //单个适应度计算   

72.     int sufficient(int i){   

73.         int flag=0;   

74.         flag=cy[i]/ty;   

75.         return flag;   

76.     }   

77.        

78.     //初始化x   

79.     void init()   

80.     {。。   

81.     }   

82.     int TenToTwo(int x){   

83.         int flag=0;   

84.         if(x>=8){   

85.             flag+=1000;x-=8;   

86.         }else if(x>=4){   

87.             flag+=100;x-=4;   

88.         }else if(x>=2){   

89.             flag+=10;x-=2;   

90.                

91.         }else if(x>=1)   

92.             flag+=1;   

93.            

94.            

95.         return flag;   

96.     }   

97.     int TwoToTen(int x){   

98.         int flag=0;   

99.         if(x>=1000){   

100.              flag+=8;x-=1000;   

101.          }else if(x>=100){   

102.              flag+=4;x-=100;   

103.          }else if(x>=2){   

104.              flag+=2;x-=10;   

105.                 

106.          }else if(x>=1)   

107.              flag+=1;   

108.             

109.          return flag;   

110.             

111.      }   

112.         

113.  }   

上面公开的有遗传算法的主函数，伪二进制转化成十进制，伪十进制转化成二进制。

下面是关于函数部分。这个有可能是要手动调整的。

Code:

1.    package 遗传算法;   

2.      

3.    public class Fuction {   

4.        public int[] x={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};   

5.        //{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};   

6.        public int fuctionValue(int x){   

7.            int flag=0;   

8.            int y=0;   

9.            y=x^5-x^4+14*x^2+19*x+7;   

10.         flag=y;   

11.         return flag;   

12.     }   

13.   

14. }   

一共代码250行。写了大概7小时。如果有探讨欢迎探讨。伸手党我也准备了伪的2~10进制相互转化。