遗传算法(GA)

遗传算法

遗传算法定义

遗传算法（Genetic Algorithm）是模拟达尔文的遗传选择和自然淘汰的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法，它是有美国Michigan大学J.Holland教授于1975年首先提出来的，并出版了颇有影响的专著《Adaptation in Natural and Artificial Systems》，GA这个名称才逐渐为人所知，J.Holland教授所提出的GA通常为简单遗传算法（SGA）。
　　遗传算法是从代表问题可能潜在的解集的一个种群（population）开始的，而一个种群则由经过基因（gene）编码的一定数目的个体(individual)组成。每个个体实际上是染色体(chromosome)带有特征的实体。染色体作为遗传物质的主要载体，即多个基因的集合，其内部表现（即基因型）是某种基因组合，它决定了个体的形状的外部表现，如黑头发的特征是由染色体中控制这一特征的某种基因组合决定的。因此，在一开始需要实现从表现型到基因型的映射即编码工作。由于仿照基因编码的工作很复杂，我们往往进行简化，如二进制编码，初代种群产生之后，按照适者生存和优胜劣汰的原理，逐代（generation）演化产生出越来越好的近似解，在每一代，根据问题域中个体的适应度（fitness）大小选择（selection）个体，并借助于自然遗传学的遗传算子（genetic operators）进行组合交叉（crossover）和变异（mutation），产生出代表新的解集的种群。这个过程将导致种群像自然进化一样的后生代种群比前代更加适应于环境，末代种群中的最优个体经过解码（decoding），可以作为问题近似最优解。

遗传算法特点

遗传算法是一类可用于复杂系统优化的具有鲁棒性的搜索算法，与传统的优化算法相比，主要有以下特点：
　　1、 遗传算法以决策变量的编码作为运算对象。传统的优化算法往往直接决策变量的实际植本身，而遗传算法处理决策变量的某种编码形式，使得我们可以借鉴生物学中的染色体和基因的概念，可以模仿自然界生物的遗传和进化机理，也使得我们能够方便的应用遗传操作算子。
　　2、 遗传算法直接以适应度作为搜索信息，无需导数等其它辅助信息。
　　3、 遗传算法使用多个点的搜索信息，具有隐含并行性。
　　4、 遗传算法使用概率搜索技术，而非确定性规则。

遗传算法的应用

由于遗传算法的整体搜索策略和优化搜索方法在计算是不依赖于梯度信息或其它辅助知识，而只需要影响搜索方向的目标函数和相应的适应度函数，所以遗传算法提供了一种求解复杂系统问题的通用框架，它不依赖于问题的具体领域，对问题的种类有很强的鲁棒性，所以广泛应用于许多科学，下面我们将介绍遗传算法的一些主要应用领域：
　　1、 函数优化。
　　函数优化是遗传算法的经典应用领域，也是遗传算法进行性能评价的常用算例，许多人构造出了各种各样复杂形式的测试函数：连续函数和离散函数、凸函数和凹函数、低维函数和高维函数、单峰函数和多峰函数等。对于一些非线性、多模型、多目标的函数优化问题，用其它优化方法较难求解，而遗传算法可以方便的得到较好的结果。
　　2、 组合优化
　　随着问题规模的增大，组合优化问题的搜索空间也急剧增大，有时在目前的计算上用枚举法很难求出最优解。对这类复杂的问题，人们已经意识到应把主要精力放在寻求满意解上，而遗传算法是寻求这种满意解的最佳工具之一。实践证明，遗传算法对于组合优化中的NP问题非常有效。例如遗传算法已经在求解旅行商问题、 背包问题、装箱问题、图形划分问题等方面得到成功的应用。
　　此外，GA也在生产调度问题、自动控制、机器人学、图象处理、人工生命、遗传编码和机器学习等方面获得了广泛的运用。

遗传算法的现状

进入90年代，遗传算法迎来了兴盛发展时期，无论是理论研究还是应用研究都成了十分热门的课题。尤其是遗传算法的应用研究显得格外活跃，不但它的应用领域扩大，而且利用遗传算法进行优化和规则学习的能力也显著提高，同时产业应用方面的研究也在摸索之中。此外一些新的理论和方法在应用研究中亦得到了迅速的发展，这些无疑均给遗传算法增添了新的活力。遗传算法的应用研究已从初期的组合优化求解扩展到了许多更新、更工程化的应用方面。
　　随着应用领域的扩展，遗传算法的研究出现了几个引人注目的新动向：一是基于遗传算法的机器学习，这一新的研究课题把遗传算法从历来离散的搜索空间的优化搜索算法扩展到具有独特的规则生成功能的崭新的机器学习算法。这一新的学习机制对于解决人工智能中知识获取和知识优化精炼的瓶颈难题带来了希望。二是遗传算法正日益和神经网络、模糊推理以及混沌理论等其它智能计算方法相互渗透和结合，这对开拓21世纪中新的智能计算技术将具有重要的意义。三是并行处理的遗传算法的研究十分活跃。这一研究不仅对遗传算法本身的发展，而且对于新一代智能计算机体系结构的研究都是十分重要的。四是遗传算法和另一个称为人工生命的崭新研究领域正不断渗透。所谓人工生命即是用计算机模拟自然界丰富多彩的生命现象，其中生物的自适应、进化和免疫等现象是人工生命的重要研究对象，而遗传算法在这方面将会发挥一定的作用，五是遗传算法和进化规划（Evolution Programming,EP）以及进化策略（Evolution Strategy,ES）等进化计算理论日益结合。EP和ES几乎是和遗传算法同时独立发展起来的，同遗传算法一样，它们也是模拟自然界生物进化机制的智能计算方法，即同遗传算法具有相同之处，也有各自的特点。目前，这三者之间的比较研究和彼此结合的探讨正形成热点。
　　1991年D.Whitey在他的论文中提出了基于领域交叉的交叉算子（Adjacency based crossover），这个算子是特别针对用序号表示基因的个体的交叉，并将其应用到了TSP问题中，通过实验对其进行了验证。
　　D.H.Ackley等提出了随即迭代遗传爬山法（Stochastic Iterated Genetic Hill-climbing，SIGH）采用了一种复杂的概率选举机制，此机制中由m个“投票者”来共同决定新个体的值（m表示群体的大小）。实验结果表明，SIGH与单点交叉、均匀交叉的神经遗传算法相比，所测试的六个函数中有四个表现出更好的性能，而且总体来讲，SIGH比现存的许多算法在求解速度方面更有竞争力。
　　H.Bersini和G.Seront将遗传算法与单一方法（simplex method）结合起来，形成了一种叫单一操作的多亲交叉算子（simplex crossover），该算子在根据两个母体以及一个额外的个体产生新个体，事实上他的交叉结果与对三个个体用选举交叉产生的结果一致。同时，文献还将三者交叉算子与点交叉、均匀交叉做了比较，结果表明，三者交叉算子比其余两个有更好的性能。
　　国内也有不少的专家和学者对遗传算法的交叉算子进行改进。2002年，戴晓明等应用多种群遗传并行进化的思想，对不同种群基于不同的遗传策略，如变异概率，不同的变异算子等来搜索变量空间，并利用种群间迁移算子来进行遗传信息交流，以解决经典遗传算法的收敛到局部最优值问题
　　2004年，赵宏立等针对简单遗传算法在较大规模组合优化问题上搜索效率不高的现象，提出了一种用基因块编码的并行遗传算法（Building-block Coded Parallel GA，BCPGA）。该方法以粗粒度并行遗传算法为基本框架，在染色体群体中识别出可能的基因块，然后用基因块作为新的基因单位对染色体重新编码，产生长度较短的染色体，在用重新编码的染色体群体作为下一轮以相同方式演化的初始群体。
　　2005年，江雷等针对并行遗传算法求解TSP问题,探讨了使用弹性策略来维持群体的多样性,使得算法跨过局部收敛的障碍,向全局最优解方向进化。

遗传算法的一般算法

遗传算法是基于生物学的，理解或编程都不太难。下面是遗传算法的一般算法：
　　创建一个随机的初始状态
　　初始种群是从解中随机选择出来的，将这些解比喻为染色体或基因，该种群被称为第一代，这和符号人工智能系统的情况不一样，在那里问题的初始状态已经给定了。
　　评估适应度
　　对每一个解(染色体)指定一个适应度的值，根据问题求解的实际接近程度来指定(以便逼近求解问题的答案)。不要把这些“解”与问题的“答案”混为一谈，可以把它理解成为要得到答案，系统可能需要利用的那些特性。
　　繁殖(包括子代突变)
　　带有较高适应度值的那些染色体更可能产生后代(后代产生后也将发生突变)。后代是父母的产物，他们由来自父母的基因结合而成，这个过程被称为“杂交”。
　　下一代
　　
　　如果新的一代包含一个解，能产生一个充分接近或等于期望答案的输出，那么问题就已经解决了。如果情况并非如此，新的一代将重复他们父母所进行的繁衍过程，一代一代演化下去，直到达到期望的解为止。
　　并行计算
　　
　　非常容易将遗传算法用到并行计算和群集环境中。一种方法是直接把每个节点当成一个并行的种群看待。然后有机体根据不同的繁殖方法从一个节点迁移到另一个节点。另一种方法是“农场主/劳工”体系结构，指定一个节点为“农场主”节点，负责选择有机体和分派适应度的值，另外的节点作为“劳工”节点，负责重新组合、变异和适应度函数的评估。
　　术语说明
　　由于遗传算法是由进化论和遗传学机理而产生的搜索算法，所以在这个算法中会用到很多生物遗传学知识，下面是我们将会用来的一些术语说明：
　　一、染色体(Chronmosome)
　　染色体又可以叫做基因型个体(individuals),一定数量的个体组成了群体(population),群体中个体的数量叫做群体大小。
　　二、基因(Gene)
　　基因是串中的元素，基因用于表示个体的特征。例如有一个串S＝1011，则其中的1，0，1，1这4个元素分别称为基因。它们的值称为等位基因(Alletes)。
　　三、基因地点(Locus)
　　基因地点在算法中表示一个基因在串中的位置称为基因位置(Gene Position)，有时也简称基因位。基因位置由串的左向右计算，例如在串 S＝1101 中，0的基因位置是3。
　　四、基因特征值(Gene Feature)
　　在用串表示整数时，基因的特征值与二进制数的权一致；例如在串 S=1011 中，基因位置3中的1，它的基因特征值为2；基因位置1中的1，它的基因特征值为8。
　　五、适应度(Fitness)
　　各个个体对环境的适应程度叫做适应度(fitness)。为了体现染色体的适应能力，引入了对问题中的每一个染色体都能进行度量的函数，叫适应度函数. 这个函数是计算个体在群体中被使用的概率。

遗传算法实例

---------来个例子，大家好理解------------
　　基于遗传算法的人工生命模拟
　　#include<stdio.h>
　　#include<stdlib.h>
　　#include<graphics.h>
　　#include<math.h>
　　#include<time.h>
　　#include<string.h>
　　#include "graph.c"
　　/* 宏定义 */
　　#define TL1 20 /* 植物性食物限制时间 */
　　#define TL2 5 /* 动物性食物限制时间 */
　　#define NEWFOODS 3 /* 植物性食物每代生成数目 */
　　#define MUTATION 0.05 /* 变异概率 */
　　#define G_LENGTH 32 /* 个体染色体长度 */
　　#define MAX_POP 100 /* 个体总数的最大值 */
　　#define MAX_FOOD 100 /* 食物总数的最大值 */
　　#define MAX_WX 60 /* 虚拟环境的长度最大值 */
　　#define MAX_WY 32 /* 虚拟环境的宽度最大值 */
　　#define SX1 330 /* 虚拟环境图左上角点x坐标 */
　　#define SY1 40 /* 虚拟环境图左上角点y坐标 */
　　#define GX 360 /* 个体数进化图形窗口的左上角点X坐标 */
　　#define GY 257 /* 个体数进化图形窗口的左上角点Y坐标 */
　　#define GXR 250 /* 个体数进化图形窗口的长度 */
　　#define GYR 100 /* 个体数进化图形窗口的宽度 */
　　#define GSTEP 2 /* 个体数进化图形窗口的X方向步长 */
　　#define R_LIFE 0.05 /* 初期产生生物数的环境比率 */
　　#define R_FOOD 0.02 /* 初期产生食物数的环境比率 */
　　#define SL_MIN 10 /* 个体寿命最小值 */
　　/* 全局变量 */
　　unsigned char gene[MAX_POP][G_LENGTH]; /* 遗传基因 */
　　unsigned char iflg[MAX_POP]; /* 个体死活状态标志变量 */
　　unsigned char fflg[MAX_FOOD]; /* 食物有无状态标志变量 */
　　unsigned char world[MAX_WX][MAX_WY]; /* 虚拟环境的数据 */
　　unsigned char /* 各中行为模式数据 */
　　life1[5][5]={{0,0,1,0,0},{0,1,0,1,0},{1,0,0,0,1},{0,1,0,1,0},{0,0,1,0,0}};
　　unsigned char
　　life2[5][5]={{1,1,1,1,1},{1,0,0,0,1},{1,0,0,0,1},{1,0,0,0,1},{1,1,1,1,1}};
　　unsigned char
　　food1[5][5]={{0,0,0,1,0},{0,0,1,1,0},{0,1,0,1,0},{0,0,1,1,0},{0,0,0,1,0}};
　　unsigned char
　　food2[5][5]={{0,0,0,1,0},{0,0,1,1,0},{0,1,1,1,0},{0,0,1,1,0},{0,0,0,1,0}};
　　int pop_size; /* 个体总数 */
　　int iatr[MAX_POP][4]; /* 个体属性 */
　　/* iatr[][0] 个体当前位置x坐标 */
　　/* iatr[][1] 个体当前位置y坐标 */
　　/* iatr[][2] 内部能量 */
　　/* iatr[][3] 年龄属性 */
　　int food_size; /* 食物总数 */
　　int fatr[MAX_FOOD][4]; /* 食物属性 */
　　/* fatr[][0] 食物当前位置x坐标 */
　　/* fatr[][1] 食物当前位置y坐标 */
　　/* fatr[][2]=0 : 植物性 =1:动物性 */
　　/* fatr[][3] 新鲜程度 */
　　int wx,wy; /* 虚拟环境的长宽度 */
　　void uni_crossover(gene,g1,g2,g3,ratio1,g_length) /* 均匀交叉 */
　　unsigned char *gene; /* 遗传基因 */
　　int g1,g2,g3; /* g1 g2 父个体编号 g3 子个体编号 */
　　double ratio1; /* 父个体g1被选中的概率 */
　　int g_length; /* 个体遗传基因的位长 */
　　{
　　unsigned char *gene1; /* 父1遗传基因的指针 */
　　unsigned char *gene2; /* 父2遗传基因的指针 */
　　unsigned char *gene3; /* 子遗传基因的指针 */
　　double rnd,r1;
　　int i;
　　gene1=gene+g_length*g1;
　　gene2=gene+g_length*g2;
　　gene3=gene+g_length*g3;
　　r1=(int)(10000.0*ratio1);
　　for(i=0;i<g_length;i++)
　　{ rnd=random(10000);
　　if(rnd<=r1) *(gene3+i)=*(gene1+i);
　　else *(gene3+i)=*(gene2+i);
　　}
　　}
　　void g_disp_unit(x,y,n)
　　/* 绘制虚拟环境的一个单元 */
　　int x,y; /* x=0,1,2....,wx-1; y=0,1,2,....,wy-1 */
　　int n; /* n=0: =1: 生物1 =2:生物2 =3:植物性食物 =4:障碍物 =5:动物性食物 */
　　{
　　int gx,gy,i,j;
　　unsigned char col;
　　gx=SX1+5*x;gy=SY1+5*y;
　　for(i=0;i<5;i++)
　　for(j=0;j<5;j++)
　　{ switch(n)
　　{ case 0: col=0; break;
　　case 1: col=life1[j] [ i]*2; break;
　　case 2: col=life2[j] [ i]*4; break;
　　case 3: col=food1[j] [ i]*6; break;
　　case 4: col=7; break;
　　case 5: col=food2[j] [ i]*11;
　　}
　　g_pset(gx+j,gy+i,col);
　　}
　　}
　　void g_draw_world() /* 显示虚拟环境画面 */
　　{
　　int i,j;
　　for(i=0;i<wy;i++)
　　for(j=0;j<wx;j++)
　　g_disp_unit(j,i,world[j] [ i]);
　　}
　　void g_draw_frame(x1,y1,x2,y2,c1,c2,c3,c4,text)
　　int x1,y1,x2,y2,c1,c2,c3,c4;
　　char *text;
　　{ int n,x3;
　　g_rectangle(x1,y1,x2,y2,c1,1);
　　g_rectangle(x1,y1,x2,y2,c2,0);
　　g_rectangle(x1,y1,x2,y1+16,c3,1);
　　g_rectangle(x1,y1,x2,y1+16,c2,0);
　　n=strlen(text);
　　x3=x1+((x2-x1-n*8)/2);
　　disp_hz16(text,x3,y1,c4);
　　}
　　void g_init_frames() /* 初始化画面 */
　　{
　　int i,j,cx,cy,x,y;
　　char text[17];
　　g_draw_frame(0,0,639,399,15,0,4,15,
　　"基于遗传算法的人工生命模拟");
　　g_draw_frame(0,16,320,170,7,0,8,15,"设定参数");
　　y=48;
　　setcolor(9);
　　disp_hz16("植物食物限制时间",16,y,15);
　　sprintf(text,"%d",TL1);
　　g_text(200,y+8,4,text);
　　y=y+24;
　　setcolor(9);
　　disp_hz16("动物食物限制时间",16,y,15);
　　sprintf(text,"%d",TL2);
　　g_text(200,y+8,4,text);
　　y=y+24;
　　setcolor(9);
　　disp_hz16("植物食物每代生成个数",16,y,15);
　　sprintf(text,"%d",NEWFOODS);
　　g_text(200,y+8,4,text);
　　y=y+24;
　　setcolor(9);
　　disp_hz16("变异概率",16,y,15);
　　i=(int)(MUTATION*100.0);
　　sprintf(text,"%d",i);
　　g_text(152,y+8,4,text);
　　g_draw_frame(0,170,320,399,7,0,8,15,"最佳基因型");
　　x=16;y=194;
　　setcolor(9);
　　disp_hz16("SP:物种号........",x,y,15);y=y+16;
　　disp_hz16("SL:寿命..........",x,y,15);y=y+16;
　　disp_hz16("VF:视野..........",x,y,15);y=y+16;
　　disp_hz16("TM:基本移动模式..",x,y,15);y=y+16;
　　disp_hz16("CM:移动特点......",x,y,15);y=y+16;
　　disp_hz16("LM:移动能耗......",x,y,15);y=y+16;
　　disp_hz16("CA:行动特点......",x,y,15);y=y+16;
　　disp_hz16("CR:善变性........",x,y,15);y=y+16;
　　disp_hz16("SA:攻击速度......",x,y,15);y=y+16;
　　disp_hz16("DA:防御能力......",x,y,15);y=y+16;
　　disp_hz16("LA:攻击能耗......",x,y,15);y=y+16;
　　disp_hz16("EF:食物吸取效率..",x,y,15);y=y+16;
　　g_draw_frame(320,16,639,207,7,0,8,15,"虚拟世界");
　　g_draw_frame(320,207,639,399,7,0,8,15,"世代个体数目变化");
　　}
　　void g_init_graph()
　　/* 个体数进化图初始化 */
　　{
　　g_rectangle(GX,GY,GX+GXR,GY+GYR,0,1);
　　g_rectangle(GX,GY,GX+GXR,GY+GYR,6,0);
　　setcolor(1);
　　disp_hz16( "生物 1",GX+5,GY-18,15);
　　g_line(GX+90,GY-10,GX+110,GY-10,1);
　　setcolor(4);
　　disp_hz16( "生物 2",GX+120,GY-18,15);
　　g_line(GX+205,GY-10,GX+225,GY-10,4);
　　setcolor(0);
　　disp_hz16("世代数",GX+168,GY+GYR+10,15);
　　g_text(GX-25,GY,0,"100");
　　g_text(GX-14,GY+GYR,0,"0");
　　}
　　void g_plot_population(gen_num,n1,n2,n1old,n2old)
　　int gen_num,n1,n2,n1old,n2old;
　　{
　　int x,y,gx,gy,x_old,y_old;
　　char text[8];
　　if(gen_num%10==0)
　　{
　　x=GX+(gen_num-1)*GSTEP;
　　g_line(x,GY+1,x,GY+GYR-1,1);
　　sprintf(text,"%d",gen_num);
　　if(gen_num<100||gen_num%20==0)
　　g_text(x-8,GY+GYR+5,15,text);
　　}
　　x_old=GX+(gen_num-1)*GSTEP;
　　x=x_old+GSTEP;
　　y_old=GY+GYR-n1old;
　　y=GY+GYR-n1;
　　g_line(x_old,y_old,x,y,1);
　　y_old=GY+GYR-n2old;
　　y=GY+GYR-n2;
　　g_line(x_old,y_old,x,y,4);
　　}
　　void g_disp_genotype() /* 显示最佳个体的遗传基因型 */
　　{
　　int i,j,n0,n1,x,y;
　　unsigned char g[G_LENGTH];
　　unsigned char bits[12][2]=
　　{ {0,0},{1,4},{5,6},{7,8},{9,11},{12,12},{13,15},
　　{16,18},{19,21},{22,24},{25,27},{28,31}};
　　/* 画面消除 */
　　g_rectangle(200,187,319,398,7,1);
　　if(pop_size!=0)
　　{
　　/* 获取各遗传因子 */
　　for(i=0;i<G_LENGTH;i++)
　　{
　　n0=0;n1=0;
　　for(j=0;jif(gene[j] [ i]==0) n0++;
　　else n1++;
　　if(n0>=n1) g [ i]=0; else g [ i]=1;
　　}
　　x=220;
　　for(i=0;i<12;i++)
　　{
　　y=202+i*16;
　　for(j=bits [ i][0];j<=bits [ i][1];j++)
　　if(g[j]==0)
　　g_text(x+(j-bits [ i][0])*16,y,4,"0");
　　else
　　g_text(x+(j-bits [ i][0])*16,y,4,"1");
　　}
　　}
　　}
　　void g_disp_char(x,y,x1,y1,x2,y2,v)
　　int x,y,x1,y1,x2,y2;
　　unsigned char v;
　　{
　　char c[10];
　　if(x>=x1&& x<=x2-8 && y>=y1 && y<=y2-10)
　　{
　　switch(v)
　　{
　　case 0: strcpy(c,"0");break;
　　case 1: strcpy(c,"+");break;
　　case 2: strcpy(c,"-");break;
　　case 3: strcpy(c,"x");
　　}
　　g_text(x,y,15,c);
　　}
　　}
　　void remove_life(n) /* 消除第n个个体 */
　　int n;
　　{
　　iflg[n]=0;
　　world[iatr[n][0]][iatr[n][1]]=0;
　　g_disp_unit(iatr[n][0],iatr[n][1],0);
　　if(food_size+1<=MAX_FOOD)
　　{
　　food_size++;
　　fatr[food_size-1][0]=iatr[n][0];
　　fatr[food_size-1][1]=iatr[n][1];
　　fatr[food_size-1][2]=1;
　　fatr[food_size-1][3]=0;
　　fflg[food_size-1]=1;
　　world[iatr[n][0]][iatr[n][1]]=5;
　　g_disp_unit(iatr[n][0],iatr[n][1],5);
　　}
　　}
　　void remove_food(n) /* 消除第n个食物 */
　　int n;
　　{
　　fflg[n]=0;
　　world[fatr[n][0]][fatr[n][1]]=0;
　　g_disp_unit(fatr[n][0],fatr[n][1],0);
　　}
　　void make_lives_and_foods() /* 设置虚拟环境中生物与食物 */
　　{
　　int x,y,i,j;
　　pop_size=0;
　　food_size=0;
　　for(y=0;y<wy;y++)
　　for(x=0;x<wx;x++)
　　{
　　if(world[x][y]==1||world[x][y]==2)
　　{
　　if(pop_size+1<=MAX_POP)
　　{
　　pop_size++;
　　/* 生成遗传因子 */
　　gene[pop_size-1][0]=world[x][y]-1;
　　for(i=1;i<G_LENGTH;i++)
　　gene[pop_size-1] [ i]=random(2);
　　/* 设定属性 */
　　iatr[pop_size-1][0]=x;
　　iatr[pop_size-1][1]=y;
　　iatr[pop_size-1][2]=70+random(30);
　　iatr[pop_size-1][3]=random(SL_MIN);
　　}
　　}
　　if(world[x][y]==3||world[x][y]==5)
　　{
　　if(food_size+1<=MAX_FOOD)
　　{
　　food_size++;
　　/* 设定属性 */
　　fatr[food_size-1][0]=x;
　　fatr[food_size-1][1]=y;
　　if(world[x][y]==3)
　　fatr[food_size-1][2]=0;
　　else
　　fatr[food_size-1][2]=1;
　　fatr[food_size-1][3]=random(TL1-1)+1;
　　}
　　}
　　}
　　}
　　void find_empty(x,y) /* 寻找虚拟环境中的空处，返回坐标 */
　　int *x,*y;
　　{
　　int ok;
　　ok=0;
　　while(ok==0)
　　{
　　*x=random(wx);*y=random(wy);
　　if(world[*x][*y]==0) ok=1;
　　}
　　}
　　void make_world() /* 随机设定人工环境 */
　　{
　　int i,j,k,num,x,y;
　　int ok,overlap;
　　char choice[3];
　　double size;
　　wx=0;
　　while(wx<10||wx>MAX_WX)
　　{
　　setcolor(15);
　　disp_hz16("虚拟环境长度(10-60)",10,210,20);
　　gscanf(300,210,4,0,3,"%s",choice);
　　wx=atoi(choice);
　　}
　　wy=0;
　　while(wy<10||wy>MAX_WY)
　　{
　　setcolor(15);
　　disp_hz16("虚拟环境宽度(10-32)",10,240,20);
　　gscanf(300,240,4,0,3,"%s",choice);
　　wy=atoi(choice);
　　}
　　for(i=0;i<wy;i++)
　　for(j=0;j<wx;j++)
　　if(i==0||i==wy-1||j==0||j==wx-1)
　　world[j] [ i]=4;
　　else world[j] [ i]=0;
　　/* 设定障碍物 */
　　size=(double)(wx*wy);
　　num=(int)(size/40.0);
　　if(num>MAX_POP) num=MAX_POP;
　　for(i=0;i<num;i++)
　　{
　　find_empty(&x,&y);
　　world[x][y]=4;
　　}
　　num=(int)(size/5.0);
　　if(num>MAX_FOOD) num=MAX_FOOD;
　　for(i=0;i<num;i++)
　　{
　　ok=0;
　　while(ok==0)
　　{
　　x=random(wx);y=random(wy);
　　if((world[x][y]!=4) &&
　　(world[x][y-1]==4 || world[x][y+1]==4 ||
　　world[x-1][y]==4 || world[x+1][y]==4))
　　{ world[x][y]=4;
　　ok=1;
　　}
　　}
　　}
　　for(y=0;y<wy;y++)
　　for(x=0;x<wx;x++)
　　if(world[x][y]==0)
　　{
　　num=0;
　　for(i=-1;i<=1;i++)
　　for(j=-1;j<=1;j++)
　　if(get_world(x+j,y+i)==4)
　　num++;
　　if(num>=6) world[x][y]=4;
　　}
　　/* 设定生物 */
　　num=(int)(size*R_LIFE);
　　for(i=0;i<num;i++)
　　{ find_empty(&x,&y);
　　world[x][y]=random(2)+1;
　　}
　　/* 设定食物 */
　　num=(int)(size*R_FOOD);
　　for(i=0;i<num;i++)
　　{
　　find_empty(&x,&y);
　　world[x][y]=3;
　　}
　　}
　　void load_world_file() /* 读取虚拟环境数据文件设定 */
　　{
　　FILE *fopen(),*fpt;
　　char st[100],c;
　　int i,j;
　　if((fpt=fopen("/ga/world","r"))==NULL) exit(-1);
　　else
　　{
　　fscanf(fpt,"%d",&wx);
　　fscanf(fpt,"%d",&wy);
　　for(i=0;i<wy;i++)
　　for(j=0;j<wx;j++)
　　fscanf(fpt,"%d",&world[j] [ i]);
　　fclose(fpt);
　　}
　　}
　　int get_world(x,y) /*坐标(x,y)处环境值 */
　　int x,y;
　　{
　　if(x>=0 && x<wx && y>=0 && y<wy)
　　return(world[x][y]);
　　else
　　return(-1);
　　}
　　int decode_gene(n,sb,bw) /* 第n个个体基因型解码 */
　　int n,sb,bw; /* sb开始位 bw位长 */
　　{
　　int i,sum;
　　sum=0;
　　for(i=sb;i<sb+bw;i++)
　　sum=sum*2+gene[n] [ i];
　　return(sum);
　　}
　　void move_pos(n,x1,y1,x2,y2) /* 个体n从(x1,y1)移动到(x2,y2) */
　　int n,x1,y1,x2,y2;
　　{
　　int sp,loss;
　　loss=decode_gene(n,12,1)+1; /* 移动消耗 */
　　iatr[n][2]=iatr[n][2]-loss; /* 内部能量更新 */
　　if(iatr[n][2]<=0) remove_life(n);
　　else
　　{
　　/* 个体属性更新 */
　　iatr[n][0]=x2;iatr[n][1]=y2; /* x,y坐标更新 */
　　/* 显示更新 */
　　sp=gene[n][0]+1;
　　g_disp_unit(x1,y1,0); /* 当前位置(x,y)图形消除 */
　　world[x1][y1]=0;
　　g_disp_unit(x2,y2,sp); /* 新位置图形表示 */
　　world[x2][y2]=sp;
　　}
　　}
　　void move_randomly(n) /* 个体n按照移动模式随机移动 */
　　int n;
　　{
　　/* 基本移动模式1 */
　　int pat1[8][2]={{1,0},{1,1},{0,1},{-1,1},
　　{-1,0},{-1,-1},{0,-1},{1,-1}};
　　/* 基本移动模式2与3 */
　　int pat2_3[2][4][2]={{{1,0},{0,1},{-1,0},{0,-1}},
　　{{1,1},{-1,1},{-1,-1},{1,-1}}};
　　int pat,x1,y1,x2,y2,rndnum;
　　pat=decode_gene(n,7,2);
　　/* pat(0,1,2,3): 表示基本移动模式 */
　　x1=iatr[n][0]; /* 当前x坐标 */
　　y1=iatr[n][1]; /* 当前y坐标 */
　　if(pat<=1) /* 基本移动模式1 */
　　{
　　rndnum=random(8);
　　x2=x1+pat1[rndnum][0]; /* 移动目的点x坐标 */
　　y2=y1+pat1[rndnum][1]; /* 移动目的点y坐标 */
　　}
　　else /* 基本移动模式2与3 */
　　{
　　rndnum=random(4);
　　x2=x1+pat2_3[pat-2][rndnum][0];
　　y2=y1+pat2_3[pat-2][rndnum][1];
　　}
　　if(x2>=0 && x2<wx && y2>=0 && y2<wy)
　　if(get_world(x2,y2)==0)
　　move_pos(n,x1,y1,x2,y2);
　　/* 非法目的点的场合不作移动 */
　　}
　　void move_individual(n) /* 个体n移动 */
　　int n;
　　{
　　int cx,cy,dx,dy,sp,vf,sumx,sumy;
　　int i,j,a,sgn[3],num;
　　double vect[8][2]={{1,0},{1,1},{0,1},{-1,1},
　　{-1,0},{-1,-1},{0,-1},{1,-1}};
　　double vx,vy,d1,d2;
　　double _cos,cos_max;
　　cx=iatr[n][0]; /* 当前x坐标 */
　　cy=iatr[n][1]; /* 当前y坐标 */
　　sp=decode_gene(n,0,1)+1; /* 生物种1和2 */
　　for(i=0;i<3;i++) /* 移动特点CM */
　　{
　　sgn [ i]=decode_gene(n,9+i,1);
　　if(sgn [ i]==0) sgn [ i]=-1;
　　}
　　sumx=0;sumy=0;num=0;
　　vf=decode_gene(n,5,2)+1; /* 视野 */
　　for(i=-vf;i<=vf;i++)
　　for(j=-vf;j<=vf;j++)
　　{
　　if(i!=0||j!=0)
　　{
　　a=get_world(cx+j,cy+i);
　　if(a==1||a==2) /* 生物 1和2 */
　　{ num++;
　　if(a==sp) /* 同种生物 */
　　{
　　sumx=sumx+sgn[0]*j;
　　sumy=sumy+sgn[0]*i;
　　}
　　else /* 异种生物 */
　　{
　　sumx=sumx+sgn[1]*j;
　　sumy=sumy+sgn[1]*i;
　　}
　　} else
　　if(a==3||a==5) /* 食物 */
　　{
　　num++;
　　sumx=sumx+sgn[2]*j;
　　sumy=sumy+sgn[2]*i;
　　}
　　}
　　}
　　if(num!=0) /* 视野内有其他生物和食物时 */
　　{
　　vx=(double)sumx/(double)num;
　　vy=(double)sumy/(double)num;
　　if(vx!=0||vy!=0)
　　{
　　cos_max=-1.0;
　　j=0;
　　for(i=0;i<8;i++)
　　{
　　d1=sqrt(vx*vx+vy*vy);
　　d2=sqrt(vect [ i][0]*vect [ i][0]+vect [ i][1]*vect [ i][1]);
　　_cos=(vx*vect [ i][0]+vy*vect [ i][1])/d1/d2;
　　if(_cos>cos_max)
　　{
　　cos_max=_cos;j=i;
　　}
　　}
　　dx=cx+(int)vect[j][0];
　　dy=cy+(int)vect[j][1];
　　if(dx>=0 && dx<wx && dy>=0 && dy<wy)
　　if(world[dx][dy]==0)
　　move_pos(n,cx,cy,dx,dy);
　　}
　　else move_randomly(n);
　　}
　　else move_randomly(n);
　　/* 视野内有其他生物和食物时 */
　　}
　　void act1_attack(n) /* 个体 n攻击行动范围内的其他生物个体 */
　　int n;
　　{
　　int sft[8][2]={{1,0},{1,1},{0,1},{-1,1},
　　{-1,0},{-1,-1},{0,-1},{1,-1}};
　　int x1,y1,x2,y2,n2;
　　int found,rndnum;
　　double attack1,attack2,sa1,sa2,da1,da2,rnd1,rnd2,La1,La2;
　　x1=iatr[n][0];y1=iatr[n][1];
　　/* 获得攻击对象的坐标(x2,y2) */
　　found=0;
　　while(found==0)
　　{
　　rndnum=random(8);
　　x2=x1+sft[rndnum][0];
　　y2=y1+sft[rndnum][1];
　　if(get_world(x2,y2)==1||get_world(x2,y2)==2)
　　found=1;
　　}
　　/* 检查攻击对象个体号n2 */
　　found=0;n2=0;
　　while(found==0)
　　{
　　if(iatr[n2][0]==x2 && iatr[n2][1]==y2 && iflg[n2]==1)
　　found=1; else n2++;
　　}
　　/* 计算双方的 Attack量 */
　　sa1=(double)decode_gene(n,19,3);
　　da1=(double)decode_gene(n,22,3);
　　sa2=(double)decode_gene(n2,19,3);
　　da2=(double)decode_gene(n2,22,3);
　　rnd1=(double)random(1001)/1000.0;
　　rnd2=(double)random(1001)/1000.0;
　　attack1=(double)iatr[n][2]+sa1*20.0/7.0*rnd1+da1*20.0/7.0*rnd2;
　　rnd1=(double)random(1001)/1000.0;
　　rnd2=(double)random(1001)/1000.0;
　　attack2=(double)iatr[n2][2]+sa2*20.0/7.0*rnd1+da2*20.0/7.0*rnd2;
　　/* 减少内部能量 */
　　La1=decode_gene(n,25,3);
　　La2=decode_gene(n2,25,3);
　　rnd1=(double)random(1001)/1000.0;
　　iatr[n][2]=iatr[n][2]-(int)((double)La1*rnd1);
　　rnd2=(double)random(1001)/1000.0;
　　iatr[n2][2]=iatr[n2][2]-(int)((double)La2*rnd2);
　　if(attack1>=attack2) /* 胜者: n 败者:n2 */
　　iatr[n2][2]=iatr[n2][2]-40;
　　else /* 胜者: n2 败者:n */
　　iatr[n][2]=iatr[n][2]-40;
　　if(iatr[n][2]<=0) remove_life(n);
　　if(iatr[n2][2]<=0) remove_life(n2);
　　}
　　void act2_eat(n) /* 个体n获取行动范围内的食物 */
　　int n;
　　{
　　int sft[8][2]={{1,0},{1,1},{0,1},{-1,1},
　　{-1,0},{-1,-1},{0,-1},{1,-1}};
　　int x1,y1,x2,y2,n2,ef;
　　int found,rndnum;
　　x1=iatr[n][0];y1=iatr[n][1];
　　/* 获取食物位置(x2,y2) */
　　found=0;
　　while(found==0)
　　{
　　rndnum=random(8);
　　x2=x1+sft[rndnum][0];
　　y2=y1+sft[rndnum][1];
　　if(get_world(x2,y2)==3||get_world(x2,y2)==5)
　　found=1;
　　}
　　/* 增加内部能量 */
　　ef=decode_gene(n,28,4); /* 食物吸取效率 */
　　iatr[n][2]=iatr[n][2]+(int)(40.0*(50.0+(double)ef*50.0/15.0)/100.0);
　　if(iatr[n][2]>100) iatr[n][2]=100;
　　/* 检查食物号n2 */
　　found=0;n2=0;
　　while(found==0)
　　{
　　if(fatr[n2][0]==x2 && fatr[n2][1]==y2 && fflg[n2]==1)
　　found=1; else n2++;
　　}
　　remove_food(n2);
　　}
　　void act3_makechild(n) /* 个体n与行动范围内的其他生物个体交配产生子个体 */
　　int n;
　　{
　　int i,j,k,x,y,x2,y2,found,n2,trial;
　　int x3,y3;
　　double rnd;
　　if(pop_size+1<=MAX_POP)
　　{
　　x=iatr[n][0];y=iatr[n][1];
　　found=0;
　　while(found==0)
　　{
　　x2=x+random(3)-1;
　　y2=y+random(3)-1;
　　if(x2!=x||y2!=y)
　　if(get_world(x2,y2)==gene[n][0]+1);
　　found=1;
　　}
　　/* 检查交配对象个体号n2 */
　　found=0; n2=0;
　　while(found==0)
　　{
　　if((iatr[n2][0]==x2 || iatr[n2][1]==y2) && iflg[n2]==1)
　　found=1; else n2++;
　　if(n2>=pop_size-1) return;
　　}
　　/* 确定产生个体位置 */
　　found=0;trial=0;
　　while(found==0 && trial<50)
　　{
　　i=random(3)-1;j=random(3)-1;
　　k=random(2);
　　if(k==0) { x3=x+i;y3=y+j;}
　　else { x3=x2+i;y3=y2+j;}
　　if(get_world(x3,y3)==0) found=1;
　　trial++;
　　}
　　if(found==1)
　　{
　　/* 个体 n与个体 n2产生子个体 */
　　pop_size++;
　　/* 均匀交叉 */
　　uni_crossover(gene,n,n2,pop_size-1,0.5,G_LENGTH);
　　/* 变异 */
　　for(i=1;i<G_LENGTH;i++)
　　{
　　rnd=random(10001)/10000.0;
　　if(rnd<=MUTATION)
　　if(gene[pop_size-1] [ i]==1)
　　gene[pop_size-1] [ i]=0;
　　else gene[pop_size-1] [ i]=1;
　　}
　　/* 交配后父个体能量减少 */
　　iatr[n][2]=iatr[n][2]-45;
　　if(iatr[n][2]<=0) remove_life(n);
　　iatr[n2][2]=iatr[n2][2]-45;
　　if(iatr[n2][2]<=0) remove_life(n2);
　　/* 子个体属性输入 */
　　iatr[pop_size-1][0]=x3;
　　iatr[pop_size-1][1]=y3;
　　iatr[pop_size-1][2]=100;
　　iatr[pop_size-1][3]=0;
　　iflg[pop_size-1]=1;
　　/* 子个体画面表示 */
　　world[x3][y3]=gene[pop_size-1][0]+1;
　　g_disp_unit(x3,y3,gene[pop_size-1][0]+1);
　　}
　　}
　　}
　　void act_individual(n) /* 为行动范围内的其他生物和食物决定行动 */
　　int n;
　　{
　　int i,j,k,pattern,action,cr,ca;
　　int act[3]; /* act[0]:攻击 act[1]:获取食物 act[2]:交配 */
　　int pat[6][3]={{1,2,3},{1,3,2},{2,1,3},
　　{3,1,2},{2,3,1},{3,2,1}};
　　/* pat:行动优先顺序 {攻击，获取食物，交配} */
　　int sp;
　　double rnd;
　　sp=decode_gene(n,0,1)+1;
　　for(i=0;i<3;i++) act [ i]=0;
　　for(i=-1;i<=1;i++)
　　for(j=-1;j<=1;j++)
　　{
　　if(i!=0||j!=0)
　　{
　　k=get_world(iatr[n][0]+j,iatr[n][1]+i);
　　if(k==1||k==2) act[0]=1;
　　if(k==3||k==5) act[1]=1;
　　if(k==sp) act[2]=1;
　　}
　　}
　　cr=decode_gene(n,16,3);
　　rnd=(double)random(10001)/10000.0;
　　if(rnd<=(double)cr/7.0)
　　{
　　action=random(3);
　　while(act[action]==0)
　　action=random(3);
　　}
　　else
　　{
　　ca=decode_gene(n,13,3); /* ca行动特点 */
　　if(ca<3) pattern=0;else pattern=ca-2;
　　/* 基本行动模式pattern 0-5 */
　　i=0;
　　action=pat[pattern] [ i]-1;
　　while( act[action]==0)
　　{
　　i++;
　　action=pat[pattern] [ i]-1;
　　}
　　}
　　switch(action+1)
　　{
　　case 1: act1_attack(n);break;
　　case 2: act2_eat(n);break;
　　case 3: act3_makechild(n);
　　}
　　}
　　void init_flags() /* 状态标志初始化 */
　　{
　　int i;
　　for(i=0;ifor(i=0;i<food_size;i++) fflg [ i]=1;
　　}
　　void act_lives() /* 改变状态(移动或行动) */
　　{
　　int i,j,k,x,y,move,a;
　　for(i=0;i{
　　if(iflg [ i]==1)
　　{
　　move=1;
　　for(j=-1;j<=1;j++)
　　for(k=-1;k<=1;k++)
　　{
　　if(j!=0||k!=0)
　　{
　　a=get_world(iatr [ i][0]+k,iatr [ i][1]+j);
　　if(a==1||a==2||a==3||a==5)
　　move=0;
　　}
　　}
　　if(move==1)
　　move_individual(i);
　　else
　　act_individual(i);
　　}
　　}
　　}
　　void increase_age() /* 个体年龄增1 */
　　{
　　int i,j,s;
　　for(i=0;i{
　　if(iflg [ i]==1)
　　{
　　j=decode_gene(i,1,4);
　　s=SL_MIN+j;
　　iatr [ i][3]++;
　　if(iatr [ i][3]>s)
　　remove_life(i);
　　}
　　}
　　}
　　void increase_frsh() /* 食物新鲜度增1 */
　　{
　　int i;
　　for(i=0;i<food_size;i++)
　　if(fflg [ i]==1)
　　{
　　fatr [ i][3]++;
　　if((fatr [ i][2]==0 && fatr [ i][3]>TL1)||
　　(fatr [ i][2]==1 && fatr [ i][3]>TL2))
　　remove_food(i);
　　}
　　}
　　void gabage_col() /* 死去个体及消减食物清除*/
　　{
　　int i,j;
　　int new_pop,new_food;
　　/* 检查食物 */
　　new_food=0;
　　for(i=0;i<food_size;i++)
　　if(fflg [ i]==1)
　　{
　　new_food++;
　　for(j=0;j<4;j++)
　　fatr[new_food-1][j]=fatr [ i][j];
　　}
　　food_size=new_food;
　　/* 检查个体 */
　　new_pop=0;
　　for(i=0;iif(iflg [ i]==1)
　　{
　　new_pop++;
　　/* 遗传基因复制 */
　　for(j=0;j<G_LENGTH;j++)
　　gene[new_pop-1][j]=gene [ i][j];
　　/* 属性复制 */
　　for(j=0;j<4;j++)
　　iatr[new_pop-1][j]=iatr [ i][j];
　　}
　　pop_size=new_pop;
　　}
　　void make_foods() /* 产生一代中植物性食物 */
　　{
　　int i,x,y;
　　for(i=0;i<NEWFOODS;i++)
　　{
　　if(food_size+1<=MAX_FOOD)
　　{
　　food_size++;
　　find_empty(&x,&y);
　　fatr[food_size-1][0]=x;
　　fatr[food_size-1][1]=y;
　　fatr[food_size-1][2]=0; /* 植物性 */
　　fatr[food_size-1][3]=0;
　　fflg[food_size-1]=1;
　　world[x][y]=3;
　　g_disp_unit(x,y,3);
　　}
　　}
　　}
　　void calc_population(n1,n2) /* 计算生物1和2 的个体数 */
　　int *n1,*n2;
　　{
　　int i,p1,p2;
　　p1=0;p2=0;
　　if(pop_size>0)
　　for(i=0;iif(gene [ i][0]==0) p1++; else p2++;
　　*n1=p1;
　　*n2=p2;
　　}
　　main() /* 主程序 */
　　{
　　int i,work;
　　int n1,n2,n1old,n2old;
　　char choice[2];
　　randomize();
　　/* 图形界面初始化 */
　　g_init();
　　settextstyle(0,0,4);
　　gprintf(220,20,4,0,"ALIFE");
　　setcolor(9);
　　disp_hz24("基于遗传算法的人工生命模拟",150,60,25);
　　setcolor(15);
　　disp_hz16("人工环境及生物分布",10,160,20);
　　disp_hz16("1:随机产生 2: 读文件产生 ==>",10,190,20);
　　gscanf(300,190,15,1,4,"%s",choice);
　　work=atoi(choice);
　　if(work==2) load_world_file();else make_world();
　　make_lives_and_foods();
　　/*状态初始化 */
　　init_flags();
　　/*计算个体数 */
　　calc_population(&n1old,&n2old);
　　/*生成初始画面*/
　　g_init_frames();
　　/*虚拟世界画面*/
　　g_draw_world();
　　/* 显示初始图形 */
　　g_init_graph();
　　for(i=1;i<121;i++)
　　{
　　/*状态初始化 */
　　init_flags();
　　/* 改变状态(移动或行动) */
　　act_lives();
　　/* 个体年龄增加 */
　　increase_age();
　　/* 食物新鲜度增加 */
　　increase_frsh();
　　/*死去个体及消减食物清除*/
　　gabage_col();
　　/*产生新的食物 */
　　make_foods();
　　/* 求生物1和2 的个体数 */
　　calc_population(&n1,&n2);
　　/* 个体数变化的图形更新 */
　　g_plot_population(i,n1,n2,n1old,n2old);
　　n1old=n1;n2old=n2;
　　/* 显示最佳遗传基因 */
　　g_disp_genotype();
　　}
　　setcolor(9);
　　disp_hz16("回车键结束",10,430,20);
　　getch();
　　}
　　java jgap实例
　　package demo;
　　import java.io.File;
　　import java.io.FileNotFoundException;
　　import org.jgap.Chromosome;
　　import org.jgap.Configuration;
　　import org.jgap.FitnessFunction;
　　import org.jgap.Gene;
　　import org.jgap.Genotype;
　　import org.jgap.IChromosome;
　　import org.jgap.UnsupportedRepresentationException;
　　import org.jgap.data.DataTreeBuilder;
　　import org.jgap.data.IDataCreators;
　　import org.jgap.impl.DefaultConfiguration;
　　import org.jgap.impl.IntegerGene;
　　import org.jgap.xml.XMLDocumentBuilder;
　　import org.jgap.xml.XMLManager;
　　import org.w3c.dom.Document;
　　import examples.MinimizingMakeChangeFitnessFunction;
　　/**
　　* Copyright: youhow.net (c) 2005-2008
　　* Company: youhow.net
　　*
　　* 遗传算法DEMO
　　* 从文件读取数字进行排序
　　*
　　* @version 1.0 (2008-6-12 neo([e-mail]))
　　*/
　　public class GaDemo
　　{
　　/**
　　* @param args
　　*/
　　public static void main(String[] args) throws Exception
　　{
　　//构型
　　Configuration conf = new DefaultConfiguration();
　　// Care that the fittest individual of the current population is
　　// always taken to the next generation.
　　// Consider: With that, the pop. size may exceed its original
　　// size by one sometimes!
　　// -------------------------------------------------------------
　　conf.setPreservFittestIndividual(true);
　　// Set the fitness function we want to use, which is our
　　// MinimizingMakeChangeFitnessFunction. We construct it with
　　// the target amount of change passed in to this method.
　　// ---------------------------------------------------------
　　FitnessFunction myFunc = new GaDemoFitnessFunction();
　　conf.setFitnessFunction(myFunc);
　　Gene[] sampleGenes = new Gene[2];
　　sampleGenes[0] = new IntegerGene(conf,0,9999999);
　　sampleGenes[1] = new IntegerGene(conf,0,9999999);
　　IChromosome sampleChromosome = new Chromosome(conf, sampleGenes);
　　conf.setSampleChromosome(sampleChromosome);
　　conf.setPopulationSize(80);
　　Genotype population;
　　try
　　{
　　Document doc = XMLManager.readFile(new File("GADEMO.xml"));
　　population = XMLManager.getGenotypeFromDocument(conf, doc);
　　}
　　catch (UnsupportedRepresentationException uex)
　　{
　　// JGAP codebase might have changed between two consecutive runs.
　　// --------------------------------------------------------------
　　population = Genotype.randomInitialGenotype(conf);
　　}
　　catch (FileNotFoundException fex)
　　{
　　population = Genotype.randomInitialGenotype(conf);
　　}
　　// Evolve the population. Since we don't know what the best answer
　　// is going to be, we just evolve the max number of times.
　　// ---------------------------------------------------------------
　　long startTime = System.currentTimeMillis();
　　for (int i = 0; i < 50; i++)
　　{
　　population.evolve();
　　}
　　long endTime = System.currentTimeMillis();
　　System.out.println("Total evolution time: " + (endTime - startTime) + " ms");
　　IChromosome bestSolutionSoFar = population.getFittestChromosome();
　　System.out.println("/t" + MinimizingMakeChangeFitnessFunction.getNumberOfCoinsAtGene(bestSolutionSoFar, 0));
　　System.out.println("/t" + MinimizingMakeChangeFitnessFunction.getNumberOfCoinsAtGene(bestSolutionSoFar, 1));
　　DataTreeBuilder builder = DataTreeBuilder.getInstance();
　　IDataCreators doc2 = builder.representGenotypeAsDocument(population);
　　// create XML document from generated tree
　　XMLDocumentBuilder docbuilder = new XMLDocumentBuilder();
　　Document xmlDoc = (Document) docbuilder.buildDocument(doc2);
　　XMLManager.writeFile(xmlDoc, new File("GADEMO.xml"));
　　}
　　}
　　package demo;
　　import org.jgap.FitnessFunction;
　　import org.jgap.IChromosome;
　　/**
　　* Copyright: youhow.net (c) 2005-2008
　　* Company: youhow.net
　　*
　　* GaDemoFitnessFunction class说明
　　*
　　* @version 1.0 (2008-6-12 neo([e-mail]))
　　*/
　　public class GaDemoFitnessFunction extends FitnessFunction
　　{
　　/**
　　* Comment for <code>serialVersionUID</code>
　　*/
　　private static final long serialVersionUID = 1L;
　　/**
　　* @see org.jgap.FitnessFunction#evaluate(org.jgap.IChromosome)
　　*/
　　@Override
　　protected double evaluate(IChromosome a_subject)
　　{
　　int totalCoins = 1;
　　int numberOfGenes = a_subject.size();
　　for (int i = 0; i < numberOfGenes; i++)
　　{
　　totalCoins += (Integer) a_subject.getGene(i).getAllele();
　　}
　　return totalCoins;
　　}
　　}

遗传算法的运算过程

选择(复制)：
　　根据各个个体的适应度，按照一定的规则或方法，从第t代群体P(t)中选择出一些优良的个体遗传到下 一代群体P(t+1)中；
　　交叉：
　　将群体P(t)内的各个个体随机搭配成对，对每一对个体，以某个概率(称为交叉概率）交换它们之间的部分染色体；
　　变异：
　　对群体P(t)中的每一个个体，以某一概率(称为变异概率)改变某一个或某一些基因座上的基因值为其他基因值。