遗传算法C程序
遗传算法详解
5.1.3 遗传算法的基本操作
一般的遗传算法都包含三个基本操作：复制 一般的遗传算法都包含三个基本操作：复制(reproduction)、 、 交叉(crossover)和变异 和变异(mutation)。 交叉 和变异 。 1. 复制 复制（又称繁殖），是从一个旧种群（ ），是从一个旧种群 复制（又称繁殖），是从一个旧种群（old population） ） 中选择生命力强的字符串（ 中选择生命力强的字符串（individual string）产生新种群 ） 的过程。或者说，复制是个体位串根据其目标函数f（ 的过程。或者说，复制是个体位串根据其目标函数 （即 适值函数）拷贝自己的过程。直观地讲， 适值函数）拷贝自己的过程。直观地讲，可以把目标函数 f看作是期望的最大效益的某种量度。根据位串的适值所 看作是期望的最大效益的某种量度。 看作是期望的最大效益的某种量度 进行的拷贝， 进行的拷贝，意味着具有较高适值的位串更有可能在下一 代中产生一个或多个子孙。显然，在复制操作过程中， 代中产生一个或多个子孙。显然，在复制操作过程中，目 标函数(适值 是该位串被复制或被淘汰的决定因素。 适值)是该位串被复制或被淘汰的决定因素 标函数 适值 是该位串被复制或被淘汰的决定因素。
复制操作的初始种群(旧种群 的生成往往是随机产生 复制操作的初始种群 旧种群)的生成往往是随机产生 旧种群 例如，通过掷硬币20次产生维数 次产生维数n＝ 的初始种群如下 的。例如，通过掷硬币 次产生维数 ＝4的初始种群如下 (正面 ，背面 ： 正面=1，背面=0)： 正面 01101 11000 01000 10011 显然， 显然，该初始种群可以看成是一个长度为五位的无符 号二进制数，将其编成四个位串，并解码为十进制的数： 号二进制数，将其编成四个位串，并解码为十进制的数： 位串1 01101 13 位串1： 位串2 11000 24 位串2： 位串3 01000 8 位串3： 位串4 10011 19 位串4：
基于C语言的遗传算法应用研究
基于C语言的遗传算法应用研究介绍遗传算法是一种受生物学启发的优化算法，通过模拟进化过程来寻找最优解。
它被广泛应用于解决各种复杂问题，如组合优化、函数优化、机器学习等领域。
在本文中，我们将讨论基于C语言的遗传算法的应用研究。
遗传算法的原理遗传算法的原理是基于自然选择和遗传机制。
它模拟了生物进化过程中的选择、复制和变异等操作。
算法通过对一个种群进行迭代操作来逐步优化解的质量，直到找到全局最优解或最优近似解。
遗传算法主要包含以下几个关键步骤： 1. 初始化种群：随机生成一组个体作为初始种群。
2. 评估适应度：根据问题的定义，对每个个体计算适应度值。
3.选择操作：根据适应度值选择优秀的个体作为父代。
4. 交叉操作：通过交叉操作，将父代的基因进行混合，生成新的子代。
5. 变异操作：对子代进行变异，引入新的基因信息。
6. 更新种群：用新的个体替代原来的个体，形成新的种群。
7. 终止条件：根据预先设定的终止条件，决定算法是否结束。
C语言在遗传算法中的应用C语言作为一种通用的高级编程语言，具有高效、灵活和可移植的特点，非常适合在遗传算法中实现。
以下是C语言在遗传算法中的几个关键应用。
种群表示C语言可以使用数组或结构体等数据结构来表示遗传算法的种群。
每个个体可以用一个固定长度的二进制串或其他数据类型来表示。
C语言提供了强大的数组操作功能，使得种群的处理和操作更加简便和高效。
适应度函数C语言可以定义适应度函数来评估每个个体的适应度值。
适应度函数根据问题的特定要求来计算一个个体的适应度值，作为选择操作的依据。
C语言提供了丰富的数学函数库，使得适应度函数的计算更加方便。
选择操作C语言可以使用多种选择算法来选择优秀的个体作为父代。
例如，可以使用轮盘赌选择、锦标赛选择等方法来实现选择操作。
C语言提供了条件语句和随机数生成等功能，使得选择操作的实现简单而灵活。
交叉操作C语言可以通过交叉操作将父代的基因混合，生成新的子代。
遗传算法的C语言程序案例
遗传算法的C语言程序案例一、说明1．本程序演示的是用简单遗传算法随机一个种群，然后根据所给的交叉率，变异率，世代数计算最大适应度所在的代数2．演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的命令；相应的输入数据和运算结果显示在其后。
3．举个例子，输入初始变量后，用y= (x1*x1)+(x2*x2)，其中-2.048<=x1,x2<=2.048作适应度函数求最大适应度即为函数的最大值4．程序流程图5．类型定义int popsize; //种群大小int maxgeneration; //最大世代数double pc; //交叉率double pm; //变异率struct individual{char chrom[chromlength+1];double value;double fitness; //适应度};int generation; //世代数int best_index;int worst_index;struct individual bestindividual; //最佳个体struct individual worstindividual; //最差个体struct individual currentbest;struct individual population[POPSIZE];3．函数声明void generateinitialpopulation();void generatenextpopulation();void evaluatepopulation();long decodechromosome(char *,int,int);void calculateobjectvalue();void calculatefitnessvalue();void findbestandworstindividual();void performevolution();void selectoperator();void crossoveroperator();void mutationoperator();void input();void outputtextreport();6．程序的各函数的简单算法说明如下：（1）．void generateinitialpopulation ()和void input ()初始化种群和遗传算法参数。
遗传算法的C语言实现（二）-----以求解TSP问题为例
遗传算法的C语⾔实现（⼆）-----以求解TSP问题为例上⼀次我们使⽤遗传算法求解了⼀个较为复杂的多元⾮线性函数的极值问题，也基本了解了遗传算法的实现基本步骤。
这⼀次，我再以经典的TSP问题为例，更加深⼊地说明遗传算法中选择、交叉、变异等核⼼步骤的实现。
⽽且这⼀次解决的是离散型问题，上⼀次解决的是连续型问题，刚好形成对照。
⾸先介绍⼀下TSP问题。
TSP(traveling salesman problem,旅⾏商问题)是典型的NP完全问题，即其最坏情况下的时间复杂度随着问题规模的增⼤按指数⽅式增长，到⽬前为⽌还没有找到⼀个多项式时间的有效算法。
TSP问题可以描述为：已知n个城市之间的相互距离，某⼀旅⾏商从某⼀个城市出发，访问每个城市⼀次且仅⼀次，最后回到出发的城市，如何安排才能使其所⾛的路线最短。
换⾔之，就是寻找⼀条遍历n个城市的路径，或者说搜索⾃然⼦集X={1,2,...,n}(X的元素表⽰对n个城市的编号)的⼀个排列P(X)={V1,V2,....,Vn},使得Td=∑d(V i,V i+1)+d(V n,V1)取最⼩值，其中,d(V i,V i+1)表⽰城市V i到V i+1的距离。
TSP问题不仅仅是旅⾏商问题，其他许多NP完全问题也可以归结为TSP问题，如邮路问题，装配线上的螺母问题和产品的⽣产安排问题等等，也使得TSP问题的求解具有更加⼴泛的实际意义。
再来说针对TSP问题使⽤遗传算法的步骤。
（1）编码问题：由于这是⼀个离散型的问题，我们采⽤整数编码的⽅式，⽤1~n来表⽰n个城市，1~n的任意⼀个排列就构成了问题的⼀个解。
可以知道，对于n个城市的TSP问题，⼀共有n!种不同的路线。
(2)种群初始化：对于N个个体的种群，随机给出N个问题的解（相当于是染⾊体）作为初始种群。
这⾥具体采⽤的⽅法是：1,2，...,n作为第⼀个个体，然后2,3，..n分别与1交换位置得到n-1个解，从2开始，3,4,...,n分别与2交换位置得到n-2个解，依次类推。
遗传算法的改进
Pm
k3 ( fmax
fmax
f) ,
favg
k4 ,
f favg f favg
其中， fmax 群体中最大的适应度值 fmax 每代群体的平均适应度值 f 要交叉的两个个体重较大的适应度值
f 要变异个体的适应度值
从上式可以看出，当适应度度值越接近最大适应 度值时，交叉率和变异率就越小，当等于最大适 应度值时，交叉率和变异率为零，这种调整方法 对于群体处于进化后期比较合适，但对于进化初 期不利，因为进化初期群体中的较优个体几乎不 发生变化，容易使进化走向局部最优解的可能性 增大。为此，可以作进一步的改进，使群体中最 大适应度值的个体的交叉率和变异率分别为 Pc2 和 Pm2 。为了保证每一代的最优个体不被破坏， 采用精英选择策略，使他们直接复制到下一代中。
在生物学中, 小生境是指特定环境下的一种生存环境, 相同的生物 生活在同一个小生境中。借鉴此概念, 遗传算法将每一代个体划分为 若干类, 每个类中选出若干适应度较大的个体作为一个类的优秀代表 组成一个种群, 再在种群中以及不同种群之间通过杂交、变异产生新 一代个体群, 同时采用预选择机制或者排挤机制或共享机制完成选择 操作。这样可以更好的保持群体的多样性, 使其具有很高的全局寻优 能力和收敛速度。
1
Pk (i
j)
exp(
f
(i) t
f
(
j))
f (i) f ( j) f (i) f ( j)
背包问题 (knapsack problem)
这是一个典型的最优化问题。
基本背包问题：设n件物体的重量分别为s1 sn
使用价值分别为 p1
p
，一个背包能承受的总重量
n
为c, 如何装包使总价值最大。
(完整版)遗传算法c语言代码
srand((unsigned)time(NULL));
for(i=0;i<num;i++)
{
bianyip[i]=(rand()%100);
bianyip[i]/=100;
}
//确定可以变异的染色体
t=0;
for(i=0;i<num;i++)
{
if(bianyip[i]<pm)
printf("\n******************是否想再一次计算(y or n)***********************\n");
fflush(stdin);
scanf("%c",&choice);
}while(choice=='y');
return 0;
}
{
flag=0;
break;
}
}
if(flag)
{
group[i].city[j]=t;
j++;
}
}
}
printf("************初始种群如下****************\n");
for(i=0;i<num;i++)
{
for(j=0;j<cities;j++)
printf("%4d",group[i].city[j]);
{
group[i].p=1-(double)group[i].adapt/(double)biggestsum;
biggestp+=group[i].p;
C语言人工智能算法实现神经网络和遗传算法
C语言人工智能算法实现神经网络和遗传算法人工智能（Artificial Intelligence）是当今科技领域中备受关注的热门话题，而C语言作为一种广泛应用的编程语言，也可以用于实现人工智能算法。
本文将详细介绍如何用C语言来实现神经网络和遗传算法，以展示其在人工智能领域的应用。
1. 神经网络神经网络是一种模仿人脑的学习和决策过程的计算模型。
它由多个神经元组成的层级结构构成，每个神经元接收来自上一层神经元输出的信号，并根据一定的权重和激活函数来计算输出。
下图展示了一个简单的神经网络结构：[图1：神经网络结构图]为了实现一个神经网络，我们需要在C语言中定义神经网络的结构体，并实现前馈传播和反向传播算法。
首先，我们需要定义神经网络的层级结构，可以使用数组或链表来表达。
每个神经元需要存储权重、偏差和激活函数等信息。
我们可以使用结构体来表示神经元的属性，例如：```Ctypedef struct Neuron {double* weights; // 权重数组double bias; // 偏差double output; // 输出} Neuron;```然后，定义神经网络的结构体：```Ctypedef struct NeuralNetwork {int numLayers; // 层数int* layerSizes; // 每层神经元数量的数组Neuron** layers; // 神经元层级的数组} NeuralNetwork;```接下来，我们需要实现神经网络的前馈传播算法。
前馈传播算法用于将输入数据从输入层传递到输出层，并计算网络的输出。
算法的伪代码如下所示：```Cfor each layer in network {for each neuron in layer {calculate neuron's weighted sum of inputs;apply activation function to obtain neuron's output;}}```最后，需要实现神经网络的反向传播算法，用于根据期望输出来调整网络的权重和偏差。
人工智能基础(习题卷19)
人工智能基础(习题卷19)第1部分：单项选择题，共53题，每题只有一个正确答案,多选或少选均不得分。
1.[单选题]()聚类算法采用概率模型来表达聚类原型。
A)K均值算法B)学习向量量化C)高斯混合聚类答案:C解析:2.[单选题]公安执法时，对嫌疑犯进行识别，采用什么技术？A)大数据B)人脸对比C)图像审核D)指纹识别答案:B解析:3.[单选题]()的目的是构造出新特征。
A)平滑处理B)特征构造C)聚集D)离散化答案:B解析:4.[单选题]LINUX中，用户编写了一个文本文件a.txt，想将该文件名称改为txt.a，下列命令()可以实现。
A)cda.txttxt.aB)echoa.txt>txt.aC)rma.txttxt.aD)cata.txt>txt.a答案:D解析:5.[单选题]用两个3x3的卷积核对一副三通道的彩色图像进卷积，得到的特征图有几个通道？A)1B)2C)3D)4答案:B解析:6.[单选题]与大数据密切相关的技术是( )A)蓝牙题答案:B解析:7.[单选题]( )也称智能相机，是一个兼具图像采集、图像处理和信息传递功能的小型机器视觉系统，是一种嵌入式计算机视觉系统。
A)PC式视觉系统B)3D视觉传感器C)智能视觉传感器D)CMOS传感器答案:C解析:8.[单选题]关于CBOW与Skip-Gram算法，以下说法不正确是？A)CBOW和Ｓkip-Gram都是可以训练向量的方法，但是skip-Gram要比CBOW更快一些B)CBOW是根据某个词前面的n个或者前后n个连续的词,来计算某个词出现概率C)无论是CBOW模型还是skip-gram模型,都是可以Huffman树作为基础的D)Skip-Gram就是根据某个词然后分别计算它前后几个词的各个概率答案:A解析:9.[单选题]神将网络训练时，常会遇到很多问题，对于梯度消失问题，我们可以通过选择使用以下哪种函数减轻该问题A)Relu 函数B)Sigmoid 函数C)tanh 函数D)Softsign 函数答案:A解析:10.[单选题]下列不属于RPA通用组件应用共享中心功能的是A)共享发布B)应用检索C)应用下载D)成果库管理答案:D解析:11.[单选题]前馈神经网络是一种简单的神经网络，各神经元分层排列，是目前应用最广泛，发展最迅速的人工神经网络之一。
遗传算法 c语言代码
以下是一个简单的遗传算法的C语言代码示例：c#include <stdio.h>#include <stdlib.h>#include <time.h>#include <math.h>#define POPULATION_SIZE 100#define GENE_LENGTH 10#define MAX_GENERATIONS 1000#define MUTATION_RATE 0.01#define CROSSOVER_RATE 0.8typedef struct Individual {char genes[GENE_LENGTH];double fitness;} Individual;double calculate_fitness(Individual* individual) {// 计算适应度函数，这里使用简单的二进制字符串中1的个数作为适应度 int count = 0;for (int i = 0; i < GENE_LENGTH; i++) {if (individual->genes[i] == '1') {count++;}}return count;}void initialize_population(Individual* population) {// 初始化种群for (int i = 0; i < POPULATION_SIZE; i++) {for (int j = 0; j < GENE_LENGTH; j++) {population[i].genes[j] = rand() % 2 ? '0' : '1';}population[i].fitness = calculate_fitness(&population[i]); }}void selection(Individual* population, Individual* parents) {// 选择操作，采用轮盘赌算法选择两个父代个体double total_fitness = 0;for (int i = 0; i < POPULATION_SIZE; i++) {total_fitness += population[i].fitness;}double rand1 = rand() / (double)RAND_MAX * total_fitness;double rand2 = rand() / (double)RAND_MAX * total_fitness;double cumulative_fitness = 0;int parent1_index = -1, parent2_index = -1;for (int i = 0; i < POPULATION_SIZE; i++) {cumulative_fitness += population[i].fitness;if (rand1 < cumulative_fitness && parent1_index == -1) {parent1_index = i;}if (rand2 < cumulative_fitness && parent2_index == -1) {parent2_index = i;}}parents[0] = population[parent1_index];parents[1] = population[parent2_index];}void crossover(Individual* parents, Individual* offspring) {// 交叉操作，采用单点交叉算法生成两个子代个体int crossover_point = rand() % GENE_LENGTH;for (int i = 0; i < crossover_point; i++) {offspring[0].genes[i] = parents[0].genes[i];offspring[1].genes[i] = parents[1].genes[i];}for (int i = crossover_point; i < GENE_LENGTH; i++) {offspring[0].genes[i] = parents[1].genes[i];offspring[1].genes[i] = parents[0].genes[i];}offspring[0].fitness = calculate_fitness(&offspring[0]);offspring[1].fitness = calculate_fitness(&offspring[1]);}void mutation(Individual* individual) {// 变异操作，以一定概率翻转基因位上的值for (int i = 0; i < GENE_LENGTH; i++) {if (rand() / (double)RAND_MAX < MUTATION_RATE) {individual->genes[i] = individual->genes[i] == '0' ? '1' : '0'; }}individual->fitness = calculate_fitness(individual);}void replace(Individual* population, Individual* offspring) {// 替换操作，将两个子代个体中适应度更高的一个替换掉种群中适应度最低的一个个体int worst_index = -1;double worst_fitness = INFINITY;for (int i = 0; i < POPULATION_SIZE; i++) {if (population[i].fitness < worst_fitness) {worst_index = i;worst_fitness = population[i].fitness;}}if (offspring[0].fitness > worst_fitness || offspring[1].fitness > worst_fitness) {if (offspring[0].fitness > offspring[1].fitness) {population[worst_index] = offspring[0];} else {population[worst_index] = offspring[1];}}}。
基于C#运用遗传算法的排课系统
在实际应用中也町能没有终止条件，目的是可以依次提供不 同的可行解以供使用者选择直到所有解给完或者使用者终 止。如果只考虑最优解的问题，可以使用迭代的适应度几乎 不变作为终止条件或者规定迭代次数。值得一提的是，有些 实际问题的可行解可能是唯一的，比如教学场地或教师资源 紧缺的情况，更严重的是如果约束条件太苛刻，甚至可能没 有可行解，在此类情况下人工干预还是有必要的。
以下是排课过程中常用的软约束条件： １）教师①老师一天之中连续上课节数；②老师课程大 部分在上午或下午；③总学分为奇数的课程一次连上三小 节；④早上８点（第一节）是否排课；⑤下午４点以后（最后 一节）是否排课；⑥中午１２点（第五节）是否排课；⑦一门课 尽量分散在一个星期中。 ２）学生①中午（１２：００）尽量不要排课；（参上完体育课 尽量不要排课；③共同科目同班级一起上；④选修科目各班 级分开选课；⑤对于总学分为偶数的课程采取两学分课连 上；⑥对于总学分为奇数的课程采取三学分课连上；⑦学生 课表中的上课时间不能过分集中。应避免一天课程很满而另 一天却一整天没课的情况。
Ｅｌｅｃｔｒｏｎｉｃ Ｄｅｓｉｇｎ Ｅｎｇｉｎｅｅｒｉｎｇ
２０１０年１２月
Ｄｅｃ．２０１０
基于Ｃ舟运用遗传算法的排课系统
王军．陈建云 （南京信息工程大学计算机软件学院，江苏南京２１００４４）
摘要：排课问题是典型的组合优化和不确定性调度问题，并且是ＮＰ完全问题。随着高校的发展，在教务管理系统中 使用的排课模型也变得越来越复杂，针对遗传算法排课中存在的初始解生成不合理及一周多学时课程不好安排的问
遗传算法
4、基本遗传算法的实现
（2）个体适应度评价： 基本遗传算法按与个体适应度成正比的概率来决定当前群体中每个个体遗传到 下一代群体中的机会多少。 如前所述，要求所有个体的适应度必须为正数或零，不能是负数。 (1) 当优化目标是求函数最大值，并且目标函数总取正值时，可以直接设定个 体的适应度F(X)就等于相应的目标函数值f(X)，即： F(X)＝f(X) (2) 对于求目标函数最小值的优化问题，理论上只需简单地对其增加一个负号 就 可将其转化为求目标函数最大值的优化问题，即： min f(X)＝max ( - f(X))
F(X) =
其中，Cmax是一个适当地相对比较大的数，它可用下面几种方法求得：
4、基本遗传算法的实现
(3) 遗传算子 基本遗传算法使用下述三种遗传算子： • 选择运算：根据每个个体的适应度值大小选择，适应度较高的个体被 遗传到下一代的概率较大。有很多种选择算子，基本遗传法使用的是： 赌轮盘选择：指个体被选中并遗传到下一代群体中的概率与该个体 的适应度大小成正比。 pi = fi / fi ( i=1,2,…,M ) 式中 pi——个体i被选中的概率；
注：在这里输入引用说明
4、基本遗传算法的实现
• 变异运算：变异（Mutation）是以较小的概率对个体编码串上的某个或某些位值进 行改变。 其目的有两个： 改善遗传算法的局部搜索能力。 维持群体的多样性，防止出现早熟现象。 基本遗传算法采用基本位变异算子：对于基本遗传算法中用二进制编码符号串所表示 的个体，若需要进行变异操作的某一基因座上的原有基因值为0，则变异操作将该 基因值变为1，反之，若原有基因值为1，则变异操作将其变为0。 基本位变异因子的具体执行过程是： Ⅰ. 对个体的每一个基因座，依变异概率pm指定其为变异点。 Ⅱ. 对每一个指定的变异点，对其基因值做取反运算或用其它等位基因值来代替， 从而产生出一个新的个体。 基本位变异运算的示例如下所示： A：1010 1 01010 基本位变异 A’：1010 0 01010
人工智能(本,2020春)
人工智能（本，2020春）连接主义认为人工智能的研究方法应采用（）方法。
选择一项：a. 行为模拟b. 功能模拟c. 结构模拟d. 特征模拟正确答案是：结构模拟图灵曾协助军方破解()的著名密码系统Enigma。
选择一项：a. 英国b. 日本c. 美国d. 德国正确答案是：德国由《大英百科全书》可知,围棋大约源起于公元前()年左右。
选择一项：a. 2000b. 4300c. 2600d. 2300正确答案是：2300下面属于常用的点角破空手段是()。
选择一项：a. 点二三b. 点三三c. 点四四d. 定天元正确答案是：点三三人类的学习类型不包括()选择一项：a. 交互学习b. 计算学习c. 记忆学习d. 规则学习正确答案是：规则学习人通过算法赋给机器的智能属于()。
选择一项：a. 认识智能空间b. 自然智能空间c. 人工智能空间d. 物物智能空间正确答案是：人工智能空间非结构化的知识的表示法是（）。
选择一项：a. 谓词逻辑表示b. 面向对象表示c. 语义网络表示d. 框架表示法正确答案是：谓词逻辑表示（）是有关问题环境的一些事物的知识，常以"…是…”的形式出现。
选择一项：a. 元知识b. 规则知识c. 控制知识d. 事实知识正确答案是：事实知识（）是有关问题的求解步骤、技巧性的知识。
选择一项：a. 元知识b. 规则知识c. 控制知识d. 事实知识正确答案是：控制知识（）不属于陈述式知识表示。
选择一项：a. 程序b. 语义网络c. 框架d. 剧本正确答案是：程序状态空间法三要点不包括（）。
选择一项：a. 代价b. 算符c. 状态空间方法。
遗传算法及其应用实例
遗传算法及其应用实例遗传算法（Genetic Algorithm）是由美国Michigan大学的Holland 教授（1969）提出，后经由De Jong（1975），Goldberg（1989）等归纳总结所形成的一类模拟进化算法。
遗传算法搜索最优解的方法是模仿生物的进化过程，即通过选择与染色体之间的交叉和变异来完成的。
遗传算法主要使用选择算子、交叉算子与变异算子来模拟生物进化，从而产生一代又一代的种群X t。
()（1）选择算子：是模拟自然选择的操作，反映“优胜劣汰”原理。
它根据每一个个体的适应度，按照一定规则或方法，从t代种群X t中选择出一些优良的个体（或作为母体，或让其遗传到下一代种()群(1)X t ）。
（2）交叉算子：是模拟有性繁殖的基因重组操作，它将从种群X t所选择的每一对母体，以一定的交叉概率交换它们之间的部分基()因。
（3）变异算子：是模拟基因突变的遗传操作，它对种群()X t中的每一个个体，以一定的变异概率改变某一个或某一些基因座上的基因值为其他的等位基因。
交叉算子与变异算子的作用都在于重组染色体基因，以生成新的个体。
遗传算法的运算过程如下：步1（初始化）确定种群规模N，交叉概率P，变异概率m P和终止进化准则；随c机生成N个个体作为初始种群(0)t←。
X；置0步2（个体评价）计算评估()X t中各个体的适应度。
步3（种群进化）3.1. 选择（母体）从()M对母体X t中运用选择算子选择出/2（M N≥）。
3.2. 交叉对所选择的/2M对母体，以概率c P执行交叉，形成M 个中间个体。
3.3. 变异对M个中间个体分别独立以概率P执行变异，形成Mm个候选个体。
3.4. 选择（子代）从上述所形成的M个候选个体中依据适应度选择出N个个体组成新一代种群(1)X t+。
步4（终止检验）如已满足终止准则，则输出(1)X t+中具有最大适应度的个体作为最优解，终止计算，否则置1t t←+并转步2。
遗传算法C语言代码
遗传算法C语言代码遗传算法C语言代码遗传算法C语言代码// GA.cpp : Defines the entry point for the console application.///*这是一个非常简单的遗传算法源代码，是由Denis Cormier (North Carolina State University)开发的，Sita S.Raghavan (University of North Carolina at Charlotte)修正。
代码保证尽可能少，实际上也不必查错。
对一特定的应用修正此代码，用户只需改变常数的定义并且定义“评价函数”即可。
注意代码的设计是求最大值，其中的目标函数只能取正值；且函数值和个体的适应值之间没有区别。
该系统使用比率选择、精华模型、单点杂交和均匀变异。
如果用 Gaussian变异替换均匀变异，可能得到更好的效果。
代码没有任何图形，甚至也没有屏幕输出，主要是保证在平台之间的高可移植性。
读者可以从, 目录 coe/evol中的文件prog.c中获得。
要求输入的文件应该命名为‘gadata.txt’；系统产生的输出文件为‘galog.txt’。
输入的文件由几行组成：数目对应于变量数。
且每一行提供次序——对应于变量的上下界。
如第一行为第一个变量提供上下界，第二行为第二个变量提供上下界，等等。
*/#include <stdio.h>#include <stdlib.h>#include <math.h>/* Change any of these parameters to match your needs *///请根据你的需要来修改以下参数#define POPSIZE 50 /* population size 种群大小*/#define MAXGENS 1000 /* max. number of generations 最大基因个数*/const int NVARS = 3; /* no. of problem variables 问题变量的个数*/#define PXOVER 0.8 /* probability of crossover 杂交概率*/#define PMUTATION 0.15 /* probability of mutation 变异概率*/#define TRUE 1#define FALSE 0int generation; /* current generation no. 当前基因个数*/int cur_best; /* best individual 最优个体*/FILE *galog; /* an output file 输出文件指针*/struct genotype /* genotype (GT), a member of the population 种群的一个基因的结构体类型*/{double gene[NVARS]; /* a string of variables 变量*/double fitness; /* GT's fitness 基因的适应度*/double upper[NVARS]; /* GT's variables upper bound 基因变量的上界*/double lower[NVARS]; /* GT's variables lower bound 基因变量的下界*/double rfitness; /* relative fitness 比较适应度*/double cfitness; /* cumulative fitness 积累适应度*/};struct genotype population[POPSIZE+1]; /* population 种群*/struct genotype newpopulation[POPSIZE+1]; /* new population; 新种群*//* replaces the old generation *///取代旧的基因/* Declaration of procedures used by this genetic algorithm *///以下是一些函数声明void initialize(void);double randval(double, double);void evaluate(void);void keep_the_best(void);void elitist(void);void select(void);void crossover(void);void Xover(int,int);void swap(double *, double *);void mutate(void);void report(void);/**************************************** ***********************//* Initialization function: Initializes the values of genes *//* within the variables bounds. It also initializes (to zero) *//* all fitness values for each member of the population. It *//* reads upper and lower bounds of each variable from the *//* input file `gadata.txt'. It randomlygenerates values *//* between these bounds for each gene of each genotype in the *//* population. The format of the input file `gadata.txt' is *//* var1_lower_bound var1_upper bound */ /* var2_lower_bound var2_upper bound ... */ /**************************************** ***********************/void initialize(void){FILE *infile;int i, j;double lbound, ubound;if ((infile = fopen("gadata.txt","r"))==NULL){fprintf(galog,"\nCannot open input file!\n");exit(1);}/* initialize variables within the bounds *///把输入文件的变量界限输入到基因结构体中for (i = 0; i < NVARS; i++){fscanf(infile, "%lf",&lbound);fscanf(infile, "%lf",&ubound);for (j = 0; j < POPSIZE; j++){population[j].fitness = 0;population[j].rfitness = 0;population[j].cfitness = 0;population[j].lower[i] = lbound;population[j].upper[i]= ubound;population[j].gene[i] = randval(population[j].lower[i],population[j].upper[i]);}}fclose(infile);}/**************************************** *******************//* Random value generator: Generates a value within bounds *//**************************************** *******************///随机数产生函数double randval(double low, double high) {double val;val = ((double)(rand()%1000)/1000.0)*(high - low) + low;return(val);}/*************************************************************//* Evaluation function: This takes a user defined function. *//* Each time this is changed, the code has to be recompiled. *//* The current function is: x[1]^2-x[1]*x[2]+x[3] *//**************************************** *********************///评价函数，可以由用户自定义，该函数取得每个基因的适应度void evaluate(void){int mem;int i;double x[NVARS+1];for (mem = 0; mem < POPSIZE; mem++){for (i = 0; i < NVARS; i++)x[i+1] = population[mem].gene[i];population[mem].fitness = (x[1]*x[1]) - (x[1]*x[2]) + x[3];}}/**************************************** ***********************//* Keep_the_best function: This function keeps track of the *//* best member of the population. Note that the last entry in *//* the array Population holds a copy of the best individual *//**************************************** ***********************///保存每次遗传后的最佳基因void keep_the_best(){int mem;int i;cur_best = 0;/* stores the index of the best individual*///保存最佳个体的索引for (mem = 0; mem < POPSIZE; mem++){if (population[mem].fitness > population[POPSIZE].fitness){cur_best = mem;population[POPSIZE].fitness = population[mem].fitness;}}/* once the best member in the population is found, copy the genes *///一旦找到种群的最佳个体，就拷贝他的基因for (i = 0; i < NVARS; i++)population[POPSIZE].gene[i] = population[cur_best].gene[i];}/**************************************** ************************//* Elitist function: The best member of the previous generation *//* is stored as the last in the array. If the best member of *//* the current generation is worse then the best member of the *//* previous generation, the latter one would replace the worst *//* member of the current population *//**************************************** ************************///搜寻杰出个体函数：找出最好和最坏的个体。
遗传算法实例
遗传算法实例.txt懂得放手的人找到轻松，懂得遗忘的人找到自由，懂得关怀的人找到幸福！女人的聪明在于能欣赏男人的聪明。
生活是灯，工作是油，若要灯亮，就要加油！相爱时，飞到天边都觉得踏实，因为有你的牵挂；分手后，坐在家里都觉得失重，因为没有了方向。
遗传算法实例:也是自己找来的，原代码有少许错误，本人都已更正了，调试运行都通过了的。
对于初学者，尤其是还没有编程经验的非常有用的一个文件遗传算法实例% 下面举例说明遗传算法 %% 求下列函数的最大值 %% f(x)=10*sin(5x)+7*cos(4x) x∈[0,10] %% 将 x 的值用一个10位的二值形式表示为二值问题，一个10位的二值数提供的分辨率是每为 (10-0)/(2^10-1)≈0.01 。
%% 将变量域 [0,10] 离散化为二值域 [0,1023], x=0+10*b/1023, 其中 b 是 [0,1023] 中的一个二值数。
%% %%--------------------------------------------------------------------------------------------------------------%%--------------------------------------------------------------------------------------------------------------%% 编程%-----------------------------------------------% 2.1初始化(编码)% initpop.m函数的功能是实现群体的初始化，popsize表示群体的大小，chromlength表示染色体的长度(二值数的长度)，% 长度大小取决于变量的二进制编码的长度(在本例中取10位)。
%遗传算法子程序%Name: initpop.m%初始化function pop=initpop(popsize,chromlength)pop=round(rand(popsize,chromlength)); % rand随机产生每个单元为 {0,1} 行数为popsize，列数为chromlength的矩阵，% roud对矩阵的每个单元进行圆整。
人工智能(本,2020春)
人工智能（本，2020春）
连接主义认为人工智能的研究方法应采用（）方法。
选择一项：
a. 行为模拟
b. 功能模拟
c. 结构模拟
d. 特征模拟
标准答案是：结构模拟
图灵曾协助军方破解()的著名密码系统Enigma。
选择一项：
a. 英国
b. 日本
c. 美国
d. 德国
标准答案是：德国
由《大英百科全书》可知,围棋大约源起于公元前()年左右。
选择一项：
a. 2000
b. 4300
c. 2600
d. 2300
标准答案是：2300
下面属于常用的点角破空手段是()。
选择一项：
a. 点二三
b. 点三三
c. 点四四
d. 定天元
标准答案是：点三三
人类的学习类型不包括()
选择一项：
a. 交互学习
b. 计算学习
c. 记忆学习
d. 规则学习
标准答案是：规则学习
人通过算法赋给机器的智能属于()。
遗传算法心得
最近在看遗传算法,查了很多资料，所以做了如下一些总结，也希望对后面研究的人有些帮助.因为初学GA,文中自己的见解，不一定全对，感兴趣的可以一起探讨.I简介基本概念遗传算法（Genetic Algorithms, GA）是一类借鉴生物界自然选择和自然遗传机制的随机化搜索算法。
它模拟自然选择和自然遗传过程中发生的繁殖、交叉和基因突变现象，在每次迭代中都保留一组候选解，并按某种指标从解群中选取较优的个体，利用遗传算子（选择、交叉和变异）对这些个体进行组合，产生新一代的候选解群，重复此过程，直到满足某种收敛指标为止。
GA的组成：（1）编码（产生初始种群）（2）适应度函数（3）遗传算子（选择、交叉、变异）（4）运行参数编码基因在一定能够意义上包含了它所代表的问题的解。
基因的编码方式有很多，这也取决于要解决的问题本身。
常见的编码方式有：（1）二进制编码，基因用0或1表示（常用于解决01背包问题）如：基因A：00100011010 （代表一个个体的染色体）（2）互换编码（用于解决排序问题，如旅行商问题和调度问题）如旅行商问题中，一串基因编码用来表示遍历的城市顺序，如：234517986,表示九个城市中，先经过城市2,再经过城市3,依此类推。
（3）树形编码（用于遗传规划中的演化编程或者表示）如，问题：给定了很多组输入和输出。
请你为这些输入输出选择一个函数，使得这个函数把每个输入尽可能近地映射为输出。
编码方法：基因就是树形结构中的一些函数。
（4）值编码（二进制编码不好用时，解决复杂的数值问题）在值编码中，每个基因就是一串取值。
这些取值可以是与问题有关任何值：整数，实数，字符或者其他一些更复杂的东西。
适应度函数遗传算法对一个个体（解）的好坏用适应度函数值来评价，适应度函数值越大，解的质量越好。
适应度函数是遗传算法进化过程的驱动力，也是进行自然选择的唯一标准，它的设计应结合求解问题本身的要求而定。
如TSP问题，遍历各城市路径之和越小越好，这样可以用可能的最大路径长度减去实际经过的路径长度，作为该问题的适应度函数。
遗传算法——耐心看完,你就掌握了遗传算法
遗传算法初教到掌握之阳早格格创做读完那个道义，您将基础掌握遗传算法，要有耐性瞅完.念了很暂，该当用一个怎么样的例子戴收大家走进遗传算法的神偶天下呢？遗传算法的有趣应用很多，诸如觅路问题，8数码问题，囚犯逆境，动做统制，找圆心问题（那是一个海中网友的提议：正在一个不准则的多边形中，觅找一个包罗正在该多边形内的最大圆圈的圆心.），TSP问题（正在以去的章节内里将搞小心介绍.），死产调动问题，人为死命模拟等.直到末尾瞅到一个非常有趣的比圆，感触由此引出的袋鼠跳问题（暂且那样喊它吧），既有趣直瞅又直达遗传算法的真量，真真非常符合动做初教者初教的例子.那一章将报告读者，我们怎么让袋鼠跳到珠穆朗玛峰上去(如果它不过早被冻坏的话).问题的提出与办理规划让咱们先去思量思量底下那个问题的办理办法.已知一元函数：图2-1当前央供正在既定的区间内找出函数的最大值.函数图像如图2-1所示.极大值、最大值、局部最劣解、局部最劣解正在办理上头提出的问题之前咱们有需要先澄浑几个以去将时常会逢到的观念：极大值、最大值、局部最劣解、局部最劣解.教过下中数教的人皆相识极大值正在一个小邻域内里左边的函数值递加，左边的函数值递减，正在图2.1内里的表示便是一个“山峰”.天然，正在图上有很多个“山峰”，所以那个函数有很多个极大值.而对付于一个函数去道，最大值便是正在所有极大值核心，最大的那个.所以极大值具备局部性，而最大值则具备局部性.果为遗传算法中每一条染色体，对付应着遗传算法的一个办理规划，普遍咱们用符合性函数（fitness function）去衡量那个办理规划的劣劣.所以从一个基果组到其解的符合度产死一个映射.所以也不妨把遗传算法的历程瞅做是一个正在多元函数内里供最劣解的历程.正在那个多维直里内里也罕见不浑的“山峰”，而那些最劣解所对付应的便是局部最劣解.而其中也会有一个“山峰”的海拔最下的，那么那个便是局部最劣解.而遗传算法的任务便是尽管爬到最下峰，而不是陷降正在一些小山峰.（其余，值得注意的是遗传算法纷歧定要找“最下的山峰”，如果问题的符合度评介越小越佳的话，那么局部最劣解便是函数的最小值，对付应的，遗传算法所要找的便是“最深的谷底”）如果于今您还不太明黑的话，那么您先往下瞅.本章的示例步调将会非常局里的表示出那个情景.“袋鼠跳”问题既然咱们把函数直线明黑成一个一个山峰战山谷组成的山脉.那么咱们不妨设念所得到的每一个解便是一只袋鼠，咱们期视它们不竭的背着更下处跳去，直到跳到最下的山峰（纵然袋鼠自己不睹得启诺那么搞）.所以供最大值的历程便转移成一个“袋鼠跳”的历程.底下介绍介绍“袋鼠跳”的几种办法.爬山法、模拟退火战遗传算法办理觅找最大值问题的几种罕睹的算法：1. 爬山法（最速降下爬山法）：从搜索空间中随机爆收相近的面，从中采用对付应解最劣的个体，替换本去的个体，不竭沉复上述历程.果为只对付“相近”的面做比较，所以目光比较“短浅”，时常只可支敛到离开初初位子比较近的局部最劣解上头.对付于存留很多局部最便宜的问题，通过一个简朴的迭代找出局部最劣解的机会非常苍茫.（正在爬山法中，袋鼠最有期视到达最靠拢它出收面的山顶，然而不克不迭包管该山顶是珠穆朗玛峰，大概者是一个非常下的山峰.果为一路上它只瞅上坡，不下坡.）2. 模拟退火：那个要收去自金属热加工历程的开收.正在金属热加工历程中，当金属的温度超出它的熔面（Melting Point）时，本子便会猛烈天随机疏通.与所有的其余的物理系统相类似，本子的那种疏通趋背于觅找其能量的极小状态.正在那个能量的变迁历程中，开初时.温度非常下，使得本子具备很下的能量.随着温度不竭降矮，金属徐徐热却，金属中的本子的能量便越去越小，末尾达到所有大概的最矮面.利用模拟退火的时间，让算法从较大的跳跃开初，使到它有足够的“能量”遁离大概“路过”的局部最劣解而不至于节制正在其中，当它停正在局部最劣解附近的时间，徐徐的减小跳跃量，以便使其“降足”到局部最劣解上.（正在模拟退火中，袋鼠喝醉了，而且随机天大跳跃了很万古间.幸运佳的话，它从一个山峰跳过山谷，到了其余一个更下的山峰上.然而末尾，它徐徐醉悟了并往着它天圆的峰顶跳去.）3. 遗传算法：模拟物竞天择的死物进化历程，通过维护一个潜正在解的集体真止了多目标的搜索，并支援那些目标上的疑息形成战接换.以里为单位的搜索，比以面为单位的搜索，更能创制局部最劣解.（正在遗传算法中，有很多袋鼠，它们降降到喜玛推俗山脉的任性场合.那些袋鼠本去不相识它们的任务是觅找珠穆朗玛峰.然而每过几年，便正在一些海拔下度较矮的场合射杀一些袋鼠，并期视存活下去的袋鼠是多产的，正在它们所处的场合死女育女.）（厥后，一个喊天止健的网游给我念了一个更恰切的故事：从前，有一大群袋鼠，它们被莫名其妙的整集天遗弃于喜马推俗山脉.于是只佳正在那边费力的死计.海拔矮的场合弥漫着一种无色有趣的毒气，海拔越下毒气越密疏.但是可怜的袋鼠们对付此齐然不觉，仍旧习惯于活蹦治跳.于是，不竭有袋鼠死于海拔较矮的场合，而越是正在海拔下的袋鼠越是能活得更暂，也越有机会死女育女.便那样通过许多年，那些袋鼠们竟然皆不自愿天散拢到了一个个的山峰上，但是正在所有的袋鼠中，惟有散拢到珠穆朗玛峰的袋鼠被戴回了劣好的澳洲.）底下主要介绍介绍遗传算法真止的历程.遗传算法的真止历程遗传算法的真止历程本量上便像自然界的进化历程那样.最先觅找一种对付问题潜正在解举止“数字化”编码的规划.（建坐表示型战基果型的映射闭系.）而后用随机数初初化一个种群（那么第一批袋鼠便被随意天分别正在山脉上.），种群内里的个体便是那些数字化的编码.接下去，通过符合的解码历程之后，（得到袋鼠的位子坐标.）用符合性函数对付每一个基果个体做一次符合度评估.（袋鼠爬得越下，越是受咱们的喜爱，所以符合度相映越下.）用采用函数依照某种确定择劣选择.（咱们要每隔一段时间，正在山上射杀一些天圆海拔较矮的袋鼠，以包管袋鼠总体数目持仄.）让个体基果接叉变同.（让袋鼠随机天跳一跳）而后爆收子代.（期视存活下去的袋鼠是多产的，并正在那边死女育女.）遗传算法本去不包管您能赢得问题的最劣解，然而是使用遗传算法的最大便宜正在于您不必去相识战担心怎么样去“找”最劣解.（您不必去指挥袋鼠背那边跳，跳多近.）而只消简朴的“可定”一些表示短佳的个体便止了.（把那些经常爱走下坡路的袋鼠射杀.）以去您会缓缓明黑那句话，那是遗传算法的粗粹！题中话：那里念提一提一个非合流的进化论瞅面：推马克主义的进化论.法国教者推马克（Jean-Baptiste de Lamarck,1744～1891）的进化论瞅面表述正在他的《动物教形而上教》（1809）一书籍中.该书籍提出死物自己存留一种是结构越收搀杂化的“内驱力”，那种内驱力是与死俱去的，正在动物中表示为“动物体新器官的爆收去自它不竭感觉到的新需要.”不过简直的死物是可变更，背什么目标变更，则要受环境的影响.推马克称其环境体制为“赢得性遗传”，那一体制分为二个阶段：一是动物器官的用与不必（即“用进兴退”：正在环境的效用下，某一器官越用越兴盛，不使用便会退化，以至消得.）；二是正在环境效用下，动物用与不必引导的后天变同通过繁殖传给后代（即“赢得性遗传”）.德国动物教家魏斯曼（August Weismann,1834～1914）对付赢得性遗传提出脆定的量疑.他用老鼠搞了一个出名的“去尾真验”，他切去老鼠的尾巴，并使之符合了短尾的死计. 用那样的老鼠举止繁殖，下一代老鼠再切去尾巴，一连切了22代老鼠的尾巴，第23代老鼠仍旧少出仄常的尾巴.由此魏斯曼认为后天后天赢得性不克不迭遗传.（择自《猜疑----科教探索的起面》）我举出那个例子，一圆里期视初教者不妨越收相识正统的进化论思维，不妨辨别进化论与真进化论的辨别.另一圆里念让读者相识的是，遗传算法虽然是一种仿死的算法，然而咱们不需要限制于仿死自己.大自然利害常聪慧的，然而不代表某些细节上人不克不迭比她更聪慧.其余，简直天道，大自然要办理的问题，到底不是咱们要办理的问题，所以办理要收上的偏偏好利害常仄常战正在所易免的.（下一章，读者便会瞅到一些非仿死而灵验的算法矫正.）譬如上头那个“赢得性遗传”咱们先不管它正在自然界存不存留，然而是对付于遗传算法的自己，有非常大的利用价格.即变同纷歧定爆收正在爆收子代的历程中，而且变同目标纷歧定是随机性的.变同不妨爆收正在符合性评估的历程核心，而且不妨是有目标性的.（天然，进一步的钻研有待举止.）所以咱们归纳出遗传算法的普遍步调：开初循环直至找到谦意的解.1.评估每条染色体所对付应个体的符合度.2.遵照符合度越下，采用概率越大的准则，从种群中采用二个个体动做女圆战母圆.3.抽与女母单圆的染色体，举止接叉，爆收子代.4.对付子代的染色体举止变同.5.沉复2，3，4步调，直到新种群的爆收.中断循环.接下去，咱们将小心天收会遗传算法历程的每一个细节.体例袋鼠的染色体----基果的编码办法通过前一章的教习，读者已经相识到人类染色体的编码标记集，由4种碱基的二种协共组成.公有4种情况，相称于2 bit的疑息量.那是人类基果的编码办法，那么咱们使用遗传算法的时间编码又该怎么样处理呢？受到人类染色体结构的开收，咱们不妨设念一下，假设暂时惟有“0”，“1”二种碱基，咱们也用一条链条把他们有序的勾通正在所有，果为每一个单位皆能表示出 1 bit的疑息量，所以一条足够少的染色体便能为咱们勾勒出一个个体的所有个性.那便是二进制编码法，染色体大概如下：上头的编码办法虽然简朴直瞅，然而明隐天，当个体个性比较搀杂的时间，需要洪量的编码才搞透彻天形貌，相映的解码历程（类似于死物教中的DNA翻译历程，便是把基果型映射到表示型的历程.）将过份复杂，为革新遗传算法的预计搀杂性、普及运算效用，提出了浮面数编码.染色体大概如下：那么咱们怎么样利用那二种编码办法去为袋鼠的染色体编码呢？果为编码的脚段是建坐表示型到基果型的映射闭系，而表示型普遍便被明黑为个体的个性.比圆人的基果型是46条染色体所形貌的（总少度二米的纸条？），却能解码成一个个眼，耳，心，鼻等个性各不相共的活死死的人.所以咱们要念为“袋鼠”的染色体编码，咱们必须先去思量“袋鼠”的“个体特征”是什么.也许有的人会道，袋鼠的个性很多，比圆性别，身少，体沉，也许它喜欢吃什么也能算做其中一个个性.然而简直正在办理那个问题的情况下，咱们该当进一步思索：无论那只袋鼠是少短，肥肥，只消它正在矮海拔便会被射杀，共时也不确定身少的袋鼠能跳得近一些，身短的袋鼠跳得近一些.天然它爱吃什么便更不相闭了.咱们由初至末皆只闭心一件事务：袋鼠正在哪里.果为只消咱们相识袋鼠正在那边，咱们便能搞二件必须去搞的事务：（1）通过查阅喜玛推俗山脉的天图去得知袋鼠天圆的海拔下度（通过自变量供函数值.）以推断咱们有出需要把它射杀.（2）相识袋鼠跳一跳后去到哪个新位子.如果咱们一时无法准确的推断哪些“个体个性”是需要的，哪些利害需要的，咱们时常不妨用到那样一种思维办法：比圆您认为袋鼠的爱吃什么物品非常需要，那么您便念一念，有二只袋鼠，它们其余的个体个性真足共等的情况下，一只爱吃草，其余一只爱吃果.您会赶快创制，那不会对付它们的运气有丝毫的效用，它们该当有共等的概率被射杀！只果它们处于共一个场合.（值得一提的是，如果您的基果编码安排中包罗了袋鼠爱吃什么的疑息，那本去不会效用到袋鼠的进化的历程，而那只攀到珠穆朗玛峰的袋鼠吃什么也完尽是随机的，然而是它天圆的位子却利害常决定的.）以上是对付遗传算法编码历程中时常经历的思维历程，必须把简直问题抽象成数教模型，超过主要冲突，放弃次要冲突.惟有那样才搞简净而灵验的办理问题.期视初教者小心琢磨.既然决定了袋鼠的位子动做个体个性，简直去道位子便是横坐标.那么接下去，咱们便要建坐表示型到基果型的映射闭系.便是道怎么样用编码去表示出袋鼠天圆的横坐标.由于横坐标是一个真数，所以道透了咱们便是要对付那个真数编码.回瞅咱们上头所介绍的二种编码办法，读者最先料到的该当便是，对付于二进制编码办法去道，编码会比较搀杂，而对付于浮面数编码办法去道，则会比较简净.恩，正如您所念的，用浮面数编码，只是需要一个浮面数而已.而底下则介绍怎么样建坐二进制编码到一个真数的映射.明隐天，一定少度的二进制编码序列，只可表示一定粗度的浮面数.譬如咱们央供解透彻到六位小数，由于区间少度为2 – (-1) = 3 ,为了包管粗度央供，起码把区间[-1,2]分为3 × 106等份.又果为所以编码的二进制串起码需要22位.把一个二进制串转移位区间内里对付应的真数值通过底下二个步调.（1）将一个二进制串代表的二进制数转移为10进制数：（2）对付应区间内的真数：由于往下章节的示例步调险些皆只用到浮面数编码，所以那个“袋鼠跳”问题的办理规划也是采与浮面数编码的.往下的步调示例（包罗拆载基果的类，突变函数）皆是针对付浮面数编码的.（对付于二进制编码那里只做简朴的介绍，不过那个“袋鼠跳”真足不妨用二进制编码去办理的，而且更灵验一些.所以读者不妨自己测验考查用二进制编码去办理.）小知识：vector（容器）的使用.正在简直写代码的历程中，读者将会一再用到vector那种数据结构，所以大家必须先对付它有所相识.std::vector是STL（standard template library）库内里的现成的模板类.它用起去便像动背数组.利用vector（容器）咱们不妨便当而且下效的对付容器内里的元素举止支配.示比圆下：1.//增加头文献，并使用std名空间.2.#include<vector>ing namespace std;4.//定义一个vector,<>内的是那个vector所拆载的典型.5.vector<int> MyVector;6.//为vector后里增加一个整型元素0.7.MyVector.push_back(0);8.//把vector的第一个元素的值赋给变量a.值得注意的是如果vector的少度惟有1，而您9.//去考察它的下一个元素的话，编译战运止皆不会报错，它会返回一个随机值给您，所以使10.//用的时间一定要注意那个潜伏的BUG.11.int a = MyVector[0];12.//把vector内里的元素局部浑空.13.MyVector.clear();14.//返回vector内里的元素的个数.15.MyVector.size()呵呵，如果您出用过那个模板类，请真足不必介意，果为当前为止，您已经教会了正在本书籍内里将用到的所有功能.另中，我也逆便提一提，为什么我用vector而不必其余数据结构比圆数组，去拆载一条基果，另有后里咱们将会教到的神经搜集中的权值背量.诚然，用数组做为基果大概者权值背量的载体，速度会快一些.然而是我用vector主要出于底下几个思量.最先，vector的使用比较便当，便当得到其大小，也便当增加战考察元素，另有排序.其次，使用vector也便于代码的维护与及沉用（正在那本书籍的教习历程中，教习者将会逐步建坐起遗传算法战人为神经搜集的引擎，通过对付代码少量的建改便能用于办理新的问题.）.其余，我还期视正在钻研更前缘的应用目标――通过遗传算法动背改变神经搜集的拓扑结构的时间，大家仍旧不妨通过少量的建改后继启利用那些代码.（果为动背天改变神经搜集的拓扑结构非常需要不规定大小的容器.）咱们定义一个类动做袋鼠基果的载体.（小心的人会提出那样的疑问：为什么我用浮面数的容器去储躲袋鼠的基果呢？袋鼠的基果不是只用一个浮面数去表示便止吗？恩，出错，到底上对付于那个真例，咱们只需要用上一个浮面数便止了.咱们那里用上容器是为了便当以去利用那些代码处理那些编码需要一串浮面数的问题.）1.class CGenome2.{3.public:4. //定义拆载基果的容器（到底上从英文阐明去瞅，Weights是权值的意义，那用去表示5.//基果的确有面名不符真，呵呵.那主假如果为那些代码去自于GA-ANN引擎，所以正在6.//它内里基果真量便是神经搜集的权值，所以习惯性的把它引进过去便只佳那样了.）7. vector <double> vecWeights;8. // dFitness用于保存对付该基果的符合性评估.9. double dFitness;10. //类的无参数初初化参数.11. CGenome():dFitness(0){}12. //类的戴参数初初化参数.13. CGenome(vector <double> w, double f): vecWeights(w), dFitness(f){}14.};佳了，暂时为止咱们把袋鼠的染色体给钻研透了，让咱们继启跟进袋鼠的进化旅程.物竞天择－－符合性评分与及采用函数.――符合度函数（fitness function）自然界死物比赛历程往往包罗二个圆里：死物相互间的搏斗与及死物与客瞅环境的搏斗历程.然而正在咱们那个真例内里，您不妨设念到，袋鼠相互之间利害常友佳的，它们本去不需要互相搏斗以争与存正在的权利.它们的死死存亡更多是与决于您的推断.果为您要衡量哪只袋鼠该杀，哪只袋鼠不该杀，所以您必须制定一个衡量的尺度.而对付于那个问题，那个衡量的尺度比较简单制定：袋鼠天圆的海拔下度.（果为您简朴天期视袋鼠爬得越下越佳.）所以咱们间接用袋鼠的海拔下度动做它们的符合性评分.即符合度函数间接返回函数值便止了.――采用函数（selection）自然界中，越符合的个体便越有大概繁殖后代.然而是也不克不迭道符合度越下的便肯定后代越多，只但是从概率上去道更多.（到底有些所处海拔下度较矮的袋鼠很幸运，遁过了您的眼睛.）那么咱们怎么去建坐那种概率闭系呢？底下咱们介绍一种时常使用的采用要收――轮盘赌（Roulette Wheel Selection）采用法.假设种群数目,某个个体其符合度为,则其被选中的概率为：比圆咱们有5条染色体，他们所对付应的符合度评分分别为：5，7，10，13，15.所以各个个体被选中的概率分别为：呵呵，有人会问为什么咱们把它喊成轮盘赌采用法啊？本去您只消瞅瞅图2-2的轮盘便会明黑了.那个轮盘是依照各个个体的符合度比率举止分块的.您不妨设念一下，咱们转化轮盘，轮盘停下去的时间，指针会随机天指背某一个个体所代表的天区，那么非常幸运天，那个个体被选中了.（很明隐，符合度评分越下的个体被选中的概率越大.）图2-2那么接下去咱们瞅瞅怎么样用代码去真止轮盘赌.1.//轮盘赌函数2.CGenome GetChromoRoulette()3.{4. //爆收一个0到人心总符合性评分总战之间的随机数.5. //中m_dTotalFitness记录了所有种群的符合性分数总战)6. double Slice = (RandFloat()) * m_dTotalFitness;7. //那个基果将拆载转盘所选出去的那个个体.8. CGenome TheChosenOne;9. //乏计符合性分数的战.10. double FitnessSoFar = 0;11. //遍历总人心内里的每一条染色体.12. for (int i=0; i<m_iPopSize; ++i)13. {14. //乏计符合性分数.15. FitnessSoFar += m_vecPop[i].dFitness;16. //如果乏计分数大于随机数,便采用此时的基果.17. if (FitnessSoFar >= Slice)18. {19. TheChosenOne = m_vecPop[i];20. break;21. }22. }23. //返回转盘选出去的个体基果24. return TheChosenOne;25.}遗传变同――基果沉组（接叉）与基果突变.该当道那二个步调便是使到子代分歧于女代的根根源基本果（注意，我不道是子代劣于女代的本果，惟有通过自然的采用后，才会出现子代劣于女代的倾背.）.对付于那二种遗传支配，二进制编码战浮面型编码正在处理上有很大的好别，其中二进制编码的遗传支配历程，比较类似于自然界内里的历程，底下将合并道述.1.基果沉组/接叉(recombination/crossover)（1）二进制编码回瞅上一章介绍的基果接叉历程：共源染色体联会的历程中，非姐妹染色单体（分别去自女母单圆）之间时常爆收接叉，而且相互接换一部分染色体，如图2-3.到底上，二进制编码的基果接换历程也非常类似那个历程――随机把其中几个位于共一位子的编码举止接换，爆收新的个体，如图2-4所示.图2-3 图2-4（2）浮面数编码如果一条基果中含有多个浮面数编码，那么也不妨用跟上头类似的要收举止基果接叉，分歧的是举止接叉的基础单位不是二进制码，而是浮面数.而如果对付于单个浮面数的基果接叉，便有其余分歧的沉组办法了，比圆中间沉组：那样只消随机爆收便能得到介于女代基果编码值战母代基果编码值之间的值动做子代基果编码的值.考虑到“袋鼠跳”问题的简直情况――袋鼠的个体个性只是表示为它所处的位子.不妨设念，共一个位子的袋鼠的基果是真足相共的，而二条相共的基果举止接叉后，相称于什么皆不搞，所以咱们不挨算正在那个例子内里使用接叉那一个遗传支配步调.（天然硬要那个支配步调也不是不可的，您不妨把二只同天的袋鼠捉到所有，让它们接配，而后爆收子代，再把它们支到它们该当到的场合.）题中话：性的起源死命进化中另一个主要的要害收达是伴伴着二性的收育――二个死物个体间遗传物量的接换而去的.正是那种接换提供了自然采用不妨爆收效用的变同火仄.性大概起源于正在某种共类相食中.一个死物吞噬了另一个死物.含有单倍遗传物量的吞噬后死物为了补救自己而一分为二.那时，一种单倍遗传物量与单倍遗传物量的单位持绝相互接换替的模式便会爆收.直至到达一个各项准则皆符合于单倍系统的环境.正在那个系统中，从单倍体到单倍体的团结只爆收正在性细胞大概配子产死中，然厥后自分歧母体的配子分散成一个新的个体而回复仄常的单倍体系统.由于二性的出现，使进化的步调加快了.（择自《凶僧斯－百科齐书籍》1999年版）由于基果接叉战二性有莫大的闭联，所以咱们不妨从那个角度去深进相识基果接叉.性此出门现是正在死物已经进化得相对付搀杂的时间.那个时间死物的基果基础产死了一种功能分块的架构.而自然界的基果接叉历程又普遍不是单个。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《遗传算法——理论、应用与软件实现》，王小平、曹立明编着西安交通大学出版社2002年第一版1./******************************************************************/2./* 基于基本遗传算法的函数最优化 SGA.C */3./* A Function Optimizer using Simple Genetic Algorithm */4./* developed from the Pascal SGA code presented by David E.Goldberg */5./* 同济大学计算机系王小平 2000年5月 */6./******************************************************************/7.#include <STDIO.H>8.#include<GRAPHICS.H>9.#include <MATH.H>10.#include "graph.c"11./* 全局变量 */12.struct individual /* 个体*/13.{14. unsigned *chrom; /* 染色体 */15.double fitness; /* 个体适应度*/16.double varible; /* 个体对应的变量值*/17.int xsite; /* 交叉位置 */18.int parent[2]; /* 父个体 */19.int *utility; /* 特定数据指针变量 */20.};21.struct bestever /* 最佳个体*/22.{23. unsigned *chrom; /* 最佳个体染色体*/24.double fitness; /* 最佳个体适应度 */25.double varible; /* 最佳个体对应的变量值 */26.int generation; /* 最佳个体生成代 */27.};28.struct individual *oldpop; /* 当前代种群 */29.struct individual *newpop; /* 新一代种群 */30.struct bestever bestfit; /* 最佳个体 */31.double sumfitness; /* 种群中个体适应度累计 */32.double max; /* 种群中个体最大适应度 */33.double avg; /* 种群中个体平均适应度 */34.double min; /* 种群中个体最小适应度 */35.float pcross; /* 交叉概率 */36.float pmutation; /* 变异概率 */37.int popsize; /* 种群大小 */38.int lchrom; /* 染色体长度*/39.int chromsize; /* 存储一染色体所需字节数 */40.int gen; /* 当前世代数 */41.int maxgen; /* 最大世代数 */42.int run; /* 当前运行次数 */43.int maxruns; /* 总运行次数 */44.int printstrings; /* 输出染色体编码的判断，0 -- 不输出, 1 -- 输出 */46.int ncross; /* 当前代交叉发生次数 */47.48./* 随机数发生器使用的静态变量 */49.static double oldrand[55];50.static int jrand;51.static double rndx2;52.static int rndcalcflag;53./* 输出文件指针 */54.FILE *outfp ;55./* 函数定义 */56.void advance_random();57.int flip(float);rnd(int, int);58.void randomize();59.double randomnormaldeviate();60.float randomperc(),rndreal(float,float);61.void warmup_random(float);62.void initialize(),initdata(),initpop();63.void initreport(),generation(),initmalloc();64.void freeall(),nomemory(char *),report();65.void writepop(),writechrom(unsigned *);66.void preselect();67.void statistics(struct individual *);68.void title(),repchar (FILE *,char *,int);69.void skip(FILE *,int);70.int select();71.void objfunc(struct individual *);72.int crossover (unsigned *, unsigned *, unsigned *, unsigned *);73.void mutation(unsigned *);74.75.76.void initialize() /* 遗传算法初始化 */77.{78./* 键盘输入遗传算法参数 */79. initdata();80./* 确定染色体的字节长度 */81. chromsize = (lchrom/(8*sizeof(unsigned)));82.if(lchrom%(8*sizeof(unsigned))) chromsize++;83./*分配给全局数据结构空间 */84. initmalloc();85./* 初始化随机数发生器 */86. randomize();87./* 初始化全局计数变量和一些数值*/88. nmutation = 0;89. ncross = 0;90. bestfit.fitness = 0.0;91. bestfit.generation = 0;92./* 初始化种群，并统计计算结果 */94. statistics(oldpop);95. initreport();96.}97.98.void initdata() /* 遗传算法参数输入 */99.{100.char answer[2];101. setcolor(9);102. disp_hz16("种群大小(20-100)：",100,150,20);103. gscanf(320,150,9,15,4,"%d", &popsize);104.if((popsize%2) != 0)105. {106. fprintf(outfp, "种群大小已设置为偶数\n");107. popsize++;108. };109. setcolor(9);110. disp_hz16("染色体长度(8-40)：",100,180,20);111. gscanf(320,180,9,15,4,"%d", &lchrom);112. setcolor(9);113. disp_hz16("是否输出染色体编码(y/n)：",100,210,20); 114. printstrings=1;115. gscanf(320,210,9,15,4,"%s", answer);116.if(strncmp(answer,"n",1) == 0) printstrings = 0; 117. setcolor(9);118. disp_hz16("最大世代数(100-300)：",100,240,20);119. gscanf(320,240,9,15,4,"%d", &maxgen);120. setcolor(9);121. disp_hz16("交叉率(0.2-0.9)：",100,270,20);122. gscanf(320,270,9,15,5,"%f", &pcross);123. setcolor(9);124. disp_hz16("变异率(0.01-0.1)：",100,300,20);125. gscanf(320,300,9,15,5,"%f", &pmutation);126.}127.128.v oid initpop() /* 随机初始化种群 */129.{130.int j, j1, k, stop;131. unsigned mask = 1;132.for(j = 0; j < popsize; j++)133. {134.for(k = 0; k < chromsize; k++)135. {136. oldpop[j].chrom[k] = 0;137.if(k == (chromsize-1))138. stop = lchrom - (k*(8*sizeof(unsigned))); 139.else140. stop =8*sizeof(unsigned);142. {143. oldpop[j].chrom[k] = oldpop[j].chrom[k]<<1;144.if(flip(0.5))145. oldpop[j].chrom[k] = oldpop[j].chrom[k]|mask;146. }147. }148. oldpop[j].parent[0] = 0; /* 初始父个体信息 */149. oldpop[j].parent[1] = 0;150. oldpop[j].xsite = 0;151. objfunc(&(oldpop[j])); /* 计算初始适应度*/152. }153.}154.155.v oid initreport() /* 初始参数输出 */156.{157.void skip();158. skip(outfp,1);159. fprintf(outfp," 基本遗传算法参数\n");160. fprintf(outfp," -------------------------------------------------\n");161. fprintf(outfp," 种群大小(popsize) = %d\n",popsize);162. fprintf(outfp," 染色体长度(lchrom) = %d\n",lchrom);163. fprintf(outfp," 最大进化代数(maxgen) = %d\n",maxgen);164. fprintf(outfp," 交叉概率(pcross) = %f\n", pcross);165. fprintf(outfp," 变异概率(pmutation) = %f\n", pmutation);166. fprintf(outfp," -------------------------------------------------\n");167. skip(outfp,1);168. fflush(outfp);169.}170.171.v oid generation()172.{173.int mate1, mate2, jcross, j = 0;174./* 每代运算前进行预选 */175. preselect();176./* 选择, 交叉, 变异 */177.do178. {179./* 挑选交叉配对 */180. mate1 = select();181. mate2 = select();182./* 交叉和变异 */183. jcross = crossover(oldpop[mate1].chrom, oldpop[mate2].chrom, newpop[j].chrom, newpop[j+1].chrom);184. mutation(newpop[j].chrom);185. mutation(newpop[j+1].chrom);186./* 解码, 计算适应度 */187. objfunc(&(newpop[j]));189. newpop[j].parent[0] = mate1+1;190. newpop[j].xsite = jcross;191. newpop[j].parent[1] = mate2+1;192. objfunc(&(newpop[j+1]));193. newpop[j+1].parent[0] = mate1+1;194. newpop[j+1].xsite = jcross;195. newpop[j+1].parent[1] = mate2+1;196. j = j + 2;197. }198.while(j < (popsize-1));199.200.}201.202.v oid initmalloc() /*为全局数据变量分配空间 */203.{204. unsigned nbytes;205.char *malloc();206.int j;207./* 分配给当前代和新一代种群内存空间 */208. nbytes = popsize*sizeof(struct individual);209.if((oldpop = (struct individual *) malloc(nbytes)) == NULL) 210. nomemory("oldpop");211.if((newpop = (struct individual *) malloc(nbytes)) == NULL) 212. nomemory("newpop");213./* 分配给染色体内存空间 */214. nbytes = chromsize*sizeof(unsigned);215.for(j = 0; j < popsize; j++)216. {217.if((oldpop[j].chrom = (unsigned *) malloc(nbytes)) == NULL) 218. nomemory("oldpop chromosomes");219.if((newpop[j].chrom = (unsigned *) malloc(nbytes)) == NULL) 220. nomemory("newpop chromosomes");221. }222.if((bestfit.chrom = (unsigned *) malloc(nbytes)) == NULL)223. nomemory("bestfit chromosome");224.225.}226.227.v oid freeall() /* 释放内存空间 */228.{229.int i;230.for(i = 0; i < popsize; i++)231. {232. free(oldpop[i].chrom);233. free(newpop[i].chrom);234. }235. free(oldpop);237. free(bestfit.chrom);238. }239.240.v oid nomemory(string) /* 内存不足，退出*/241.char *string;242.{243. fprintf(outfp,"malloc: out of memory making %s!!\n",string);244. exit(-1);245.}246.247.v oid report() /* 输出种群统计结果 */248.{249.void repchar(), skip();250.void writepop(), writestats();251. repchar(outfp,"-",80);252. skip(outfp,1);253.if(printstrings == 1)254. {255. repchar(outfp," ",((80-17)/2));256. fprintf(outfp,"模拟计算统计报告 \n");257. fprintf(outfp, "世代数 %3d", gen);258. repchar(outfp," ",(80-28));259. fprintf(outfp, "世代数 %3d\n", (gen+1));260. fprintf(outfp,"个体染色体编码");261. repchar(outfp," ",lchrom-5);262. fprintf(outfp,"适应度父个体交叉位置 ");263. fprintf(outfp,"染色体编码 ");264. repchar(outfp," ",lchrom-5);265. fprintf(outfp,"适应度\n");266. repchar(outfp,"-",80);267. skip(outfp,1);268. writepop(outfp);269. repchar(outfp,"-",80);270. skip(outfp,1);271. }272. fprintf(outfp,"第 %d 代统计: \n",gen);273. fprintf(outfp,"总交叉操作次数 = %d, 总变异操作数 = %d\n",ncross,nmutation); 274. fprintf(outfp," 最小适应度：%f 最大适应度：%f 平均适应度 %f\n", min,max,avg); 275. fprintf(outfp," 迄今发现最佳个体 => 所在代数： %d ", bestfit.generation); 276. fprintf(outfp," 适应度：%f 染色体：", bestfit.fitness);277. writechrom((&bestfit)->chrom);278. fprintf(outfp," 对应的变量值: %f", bestfit.varible);279. skip(outfp,1);280. repchar(outfp,"-",80);281. skip(outfp,1);282.}283.285.{286.struct individual *pind;287.int j;288.for(j=0; j<POPSIZE; writechrom(pind- pind="&(oldpop[j]);" * 当前代个体 ?,j+1); fprintf(outfp,?%3d) { j++)>fitness);289. }290.}291.292.v oid writechrom(chrom) /* 输出染色体编码 */293.u nsigned *chrom;294.{295.int j, k, stop;296. unsigned mask = 1, tmp;297.for(k = 0; k < chromsize; k++)298. {299. tmp = chrom[k];300.if(k == (chromsize-1))301. stop = lchrom - (k*(8*sizeof(unsigned)));302.else303. stop =8*sizeof(unsigned);304.for(j = 0; j < stop; j++)305. {306.if(tmp&mask)307. fprintf(outfp,"1");308.else309. fprintf(outfp,"0");310. tmp = tmp>>1;311. }312. }313.}314.315.v oid preselect()316.{317.int j;318. sumfitness = 0;319.for(j = 0; j < popsize; j++) sumfitness += oldpop[j].fitness; 320.}321.322.i nt select() /* 轮盘赌选择*/323.{324.extern float randomperc();325.float sum, pick;326.int i;327. pick = randomperc();328. sum = 0;329.if(sumfitness != 0)330. {332. sum += oldpop[i].fitness/sumfitness;333. }334.else335. i = rnd(1,popsize);336.return(i-1);337.}338.339.v oid statistics(pop) /* 计算种群统计数据 */340.s truct individual *pop;341.{342.int i, j;343. sumfitness = 0.0;344. min = pop[0].fitness;345. max = pop[0].fitness;346./* 计算最大、最小和累计适应度 */347.for(j = 0; j < popsize; j++)348. {349. sumfitness = sumfitness + pop[j].fitness; 350.if(pop[j].fitness > max) max = pop[j].fitness; 351.if(pop[j].fitness < min) min = pop[j].fitness; 352./* new global best-fit individual */353.if(pop[j].fitness > bestfit.fitness)354. {355.for(i = 0; i < chromsize; i++)356. bestfit.chrom[i] = pop[j].chrom[i];357. bestfit.fitness = pop[j].fitness;358. bestfit.varible = pop[j].varible;359. bestfit.generation = gen;360. }361. }362./* 计算平均适应度 */363. avg = sumfitness/popsize;364.}365.366.v oid title()367.{368. settextstyle(0,0,4);369. gprintf(110,15,4,0,"SGA Optimizer");370. setcolor(9);371. disp_hz24("基本遗传算法",220,60,25);372.}373.374.v oid repchar (outfp,ch,repcount)375.F ILE *outfp;376.c har *ch;377.i nt repcount;378.{380.for (j = 1; j <= repcount; j++) fprintf(outfp,"%s", ch);381.}382.383.v oid skip(outfp,skipcount)384.F ILE *outfp;385.i nt skipcount;386.{387.int j;388.for (j = 1; j <= skipcount; j++) fprintf(outfp,"\n");389.}390.391.v oid objfunc(critter) /* 计算适应度函数值 */392.s truct individual *critter;393.{394. unsigned mask=1;395. unsigned bitpos;396. unsigned tp;397.double pow(), bitpow ;398.int j, k, stop;399. critter->varible = 0.0;400.for(k = 0; k < chromsize; k++)401. {402.if(k == (chromsize-1))403. stop = lchrom-(k*(8*sizeof(unsigned)));404.else405. stop =8*sizeof(unsigned);406. tp = critter->chrom[k];407.for(j = 0; j < stop; j++)408. {409. bitpos = j + (8*sizeof(unsigned))*k;410.if((tp&mask) == 1)411. {412. bitpow = pow(2.0,(double) bitpos);413. critter->varible = critter->varible + bitpow;414. }415. tp = tp>>1;416. }417. }418. critter->varible =-1+critter->varible*3/(pow(2.0,(double)lchrom)-1); 419. critter->fitness =critter->varible*sin(critter->varible*10*atan(1)*4)+2.0; 420.}421.422.v oid mutation(unsigned *child) /*变异操作*/423.{424.int j, k, stop;425. unsigned mask, temp = 1;426.for(k = 0; k < chromsize; k++)428. mask = 0;429.if(k == (chromsize-1))430. stop = lchrom - (k*(8*sizeof(unsigned)));431.else432. stop = 8*sizeof(unsigned);433.for(j = 0; j < stop; j++)434. {435.if(flip(pmutation))436. {437. mask = mask|(temp<<J); * { if(jcross k++) <="chromsize;" k for(k="1;" ncross++; l-1 and 1 between Cross 1)); - ,(lchrom jcross="rnd(1"if(flip(pcross)) temp; mask, unsigned k; jcross, j, int由两个父个体交叉产生两个子个体 *child2) *child1, *parent2, *parent1, (unsigned crossover } child[k]="child[k]^mas k;" nmutation++;>= (k*(8*sizeof(unsigned))))438. {439. child1[k-1] = parent1[k-1];440. child2[k-1] = parent2[k-1];441. }442.else if((jcross < (k*(8*sizeof(unsigned)))) && (jcross > ((k-1)*(8*sizeo f(unsigned)))))443. {444. mask = 1;445.for(j = 1; j <= (jcross-1-((k-1)*(8*sizeof(unsigned)))); j++) 446. {447. temp = 1;448. mask = mask<<1;449. mask = mask|temp;450. }451. child1[k-1] = (parent1[k-1]&mask)|(parent2[k-1]&(~mask));452. child2[k-1] = (parent1[k-1]&(~mask))|(parent2[k-1]&mask);453. }454.else455. {456. child1[k-1] = parent2[k-1];457. child2[k-1] = parent1[k-1];458. }459. }460. }461.else462. {463.for(k = 0; k < chromsize; k++)464. {465. child1[k] = parent1[k];466. child2[k] = parent2[k];467. }468. jcross = 0;469. }471.}472.473.v oid advance_random() /* 产生55个随机数 */474.{475.int j1;476.double new_random;477.for(j1 = 0; j1 < 24; j1++)478. {479. new_random = oldrand[j1] - oldrand[j1+31];480.if(new_random < 0.0) new_random = new_random + 1.0; 481. oldrand[j1] = new_random;482. }483.for(j1 = 24; j1 < 55; j1++)484. {485. new_random = oldrand [j1] - oldrand [j1-24];486.if(new_random < 0.0) new_random = new_random + 1.0; 487. oldrand[j1] = new_random;488. }489.}490.491.i nt flip(float prob) /* 以一定概率产生0或1 */492.{493.float randomperc();494.if(randomperc() <= prob)495.return(1);496.else497.return(0);498.}499.500.v oid randomize() /* 设定随机数种子并初始化随机数发生器 */ 501.{502.float randomseed;503.int j1;504.for(j1=0; j1<=54; j1++)505. oldrand[j1] = 0.0;506. jrand=0;507.do508. {509. setcolor(9);510. disp_hz16("随机数种子[0-1]:",100,330,20);511. gscanf(320,330,9,15,4,"%f", &randomseed);512. }513.while((randomseed < 0.0) || (randomseed > 1.0)); 514. warmup_random(randomseed);515.}516.517.d ouble randomnormaldeviate() /* 产生随机标准差 */518.{519.double sqrt(), log(), sin(), cos();520.float randomperc();521.double t, rndx1;522.if(rndcalcflag)523. { rndx1 = sqrt(- 2.0*log((double) randomperc()));524. t = 6.2831853072 * (double) randomperc();525. rndx2 = rndx1 * sin(t);526. rndcalcflag = 0;527.return(rndx1 * cos(t));528. }529.else530. {531. rndcalcflag = 1;532.return(rndx2);533. }534.}535.536.f loat randomperc() /*与库函数random()作用相同, 产生[0,1]之间一个随机数 */ 537.{538. jrand++;539.if(jrand >= 55)540. {541. jrand = 1;542. advance_random();543. }544.return((float) oldrand[jrand]);545.}546.547.i nt rnd(low, high) /*在整数low和high之间产生一个随机整数*/548.i nt low,high;549.{550.int i;551.float randomperc();552.if(low >= high)553. i = low;554.else555. {556. i = (randomperc() * (high - low + 1)) + low;557.if(i > high) i = high;558. }559.return(i);560.}561.562.563.v oid warmup_random(float random_seed) /* 初始化随机数发生器*/564.{565.int j1, ii;566.double new_random, prev_random;567.568. oldrand[54] = random_seed;569. new_random = 0.000000001;570. prev_random = random_seed;571.for(j1 = 1 ; j1 <= 54; j1++)572. {573. ii = (21*j1)%54;574. oldrand[ii] = new_random;575. new_random = prev_random-new_random;576.if(new_random<0.0) new_random = new_random + 1.0;577. prev_random = oldrand[ii];578. }579. advance_random();580. advance_random();581. advance_random();582. jrand = 0;583.}584.585.586.m ain(argc,argv) /* 主程序 */587.i nt argc;588.c har *argv[];589.{590.struct individual *temp;591.FILE *fopen();592.void title();593.char *malloc();594.if((outfp = fopen(argv[1],"w")) == NULL)595. {596. fprintf(stderr,"Cannot open output file %s\n",argv[1]);597. exit(-1);598. }599. g_init();600. setcolor(9);601. title();602. disp_hz16("输入遗传算法执行次数(1-5):",100,120,20);603. gscanf(320,120,9,15,4,"%d",&maxruns);604.for(run=1; run<=maxruns; run++)605. {606. initialize();607.for(gen=0; gen<MAXGEN; * { } pre < freeall(); newpop="temp;" oldpop="newpop ;" temp="oldpop;" report(); 输出新一代统计数据 statistics(newpop); 计算新一代种群的适应度统计数据 generation(); 产生新一代 run,maxruns,gen,maxgen); 代\n?, %d 共 %d, 当前代为次运行: fprintf(outfp,?\n第 gen++)>608.<SCRIPT src="/inc/gg_read2.js"></SCRIPT>。