本文目录
- 谁能给一个C语言的遗传算法例题
- 遗传算法 算子有哪些
- 通过一个实例，叙述该混合遗传算法的基本思想是什么其基本构成原则是什么
- 如何用遗传算法来处理多约束求相关的例题说明
- 遗传算法中常用的适应度函数是什么呢
- 求利用遗传算法实现矩形件排样 的VC编程案例
- 智能算法30个案例分析这本书关于遗传算法的程序解释
谁能给一个C语言的遗传算法例题
这是一个非常简单的遗传算法源代码，是由Denis Cormier (North Carolina State University)开发的，Sita S.Raghavan (University of North Carolina at Charlotte)修正。代码保证尽可能少，实际上也不必查错。对一特定的应用修正此代码，用户只需改变常数的定义并且定义“评价函数”即可。注意代码的设计是求最大值，其中的目标函数只能取正值；且函数值和个体的适应值之间没有区别。该系统使用比率选择、精华模型、单点杂交和均匀变异。如果用Gaussian变异替换均匀变异，可能得到更好的效果。代码没有任何图形，甚至也没有屏幕输出，主要是保证在平台之间的高可移植性。读者可以从ftp.uncc.edu,目录 coe/evol中的文件prog.c中获得。要求输入的文件应该命名为‘gadata.txt’；系统产生的输出文件为‘galog.txt’。输入的文件由几行组成：数目对应于变量数。且每一行提供次序——对应于变量的上下界。如第一行为第一个变量提供上下界，第二行为第二个变量提供上下界，等等。
/**************************************************************************/
/* This is a simple genetic algorithm implementation where the */
/* evaluation function takes positive values only and the */
/* fitness of an individual is the same as the value of the */
/* objective function */
/**************************************************************************/
#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 */
#define 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 0
int 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 randomly generates 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^2-x*x+x */
/*************************************************************/
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*x) - (x*x) + x;
}
}
/***************************************************************/
/* 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 */
/****************************************************************/
void elitist()
{
int i;
double best, worst; /* best and worst fitness values */
int best_mem, worst_mem; /* indexes of the best and worst member */
best = population.fitness;
worst = population.fitness;
for (i = 0; i 《 POPSIZE - 1; ++i)
{
if(population[i].fitness 》 population[i+1].fitness)
{
if (population[i].fitness 》= best)
{
best = population[i].fitness;
best_mem = i;
}
if (population[i+1].fitness 《= worst)
{
worst = population[i+1].fitness;
worst_mem = i + 1;
}
}
else
{
if (population[i].fitness 《= worst)
{
worst = population[i].fitness;
worst_mem = i;
}
if (population[i+1].fitness 》= best)
{
best = population[i+1].fitness;
best_mem = i + 1;
}
}
}
/* if best individual from the new population is better than */
/* the best individual from the previous population, then */
/* copy the best from the new population; else replace the */
/* worst individual from the current population with the */
/* best one from the previous generation */
if (best 》= population[POPSIZE].fitness)
{
for (i = 0; i 《 NVARS; i++)
population[POPSIZE].gene[i] = population[best_mem].gene[i];
population[POPSIZE].fitness = population[best_mem].fitness;
}
else
{
for (i = 0; i 《 NVARS; i++)
population[worst_mem].gene[i] = population[POPSIZE].gene[i];
population[worst_mem].fitness = population[POPSIZE].fitness;
}
}
/**************************************************************/
/* Selection function: Standard proportional selection for */
/* maximization problems incorporating elitist model - makes */
/* sure that the best member survives */
/**************************************************************/
void select(void)
{
int mem, i, j, k;
double sum = 0;
double p;
/* find total fitness of the population */
for (mem = 0; mem 《 POPSIZE; mem++)
{
sum += population[mem].fitness;
}
/* calculate relative fitness */
for (mem = 0; mem 《 POPSIZE; mem++)
{
population[mem].rfitness = population[mem].fitness/sum;
}
population.cfitness = population.rfitness;
/* calculate cumulative fitness */
for (mem = 1; mem 《 POPSIZE; mem++)
{
population[mem].cfitness = population[mem-1].cfitness +
population[mem].rfitness;
}
/* finally select survivors using cumulative fitness. */
for (i = 0; i 《 POPSIZE; i++)
{
p = rand()%1000/1000.0;
if (p 《 population.cfitness)
newpopulation[i] = population;
else
{
for (j = 0; j 《 POPSIZE;j++)
if (p 》= population[j].cfitness &&
p《population[j+1].cfitness)
newpopulation[i] = population[j+1];
}
}
/* once a new population is created, copy it back */
for (i = 0; i 《 POPSIZE; i++)
population[i] = newpopulation[i];
}
/***************************************************************/
/* Crossover selection: selects two parents that take part in */
/* the crossover. Implements a single point crossover */
/***************************************************************/
void crossover(void)
{
int i, mem, one;
int first = 0; /* count of the number of members chosen */
double x;
for (mem = 0; mem 《 POPSIZE; ++mem)
{
x = rand()%1000/1000.0;
if (x 《 PXOVER)
{
++first;
if (first % 2 == 0)
Xover(one, mem);
else
one = mem;
}
}
}
/**************************************************************/
/* Crossover: performs crossover of the two selected parents. */
/**************************************************************/
void Xover(int one, int two)
{
int i;
int point; /* crossover point */
/* select crossover point */
if(NVARS 》 1)
{
if(NVARS == 2)
point = 1;
else
point = (rand() % (NVARS - 1)) + 1;
for (i = 0; i 《 point; i++)
swap(&population[one].gene[i], &population[two].gene[i]);
}
}
/*************************************************************/
/* Swap: A swap procedure that helps in swapping 2 variables */
/*************************************************************/
void swap(double *x, double *y)
{
double temp;
temp = *x;
*x = *y;
*y = temp;
}
/**************************************************************/
/* Mutation: Random uniform mutation. A variable selected for */
/* mutation is replaced by a random value between lower and */
/* upper bounds of this variable */
/**************************************************************/
void mutate(void)
{
int i, j;
double lbound, hbound;
double x;
for (i = 0; i 《 POPSIZE; i++)
for (j = 0; j 《 NVARS; j++)
{
x = rand()%1000/1000.0;
if (x 《 PMUTATION)
{
/* find the bounds on the variable to be mutated */
lbound = population[i].lower[j];
hbound = population[i].upper[j];
population[i].gene[j] = randval(lbound, hbound);
}
}
}
/***************************************************************/
/* Report function: Reports progress of the simulation. Data */
/* dumped into the output file are separated by commas */
/***************************************************************/
void report(void)
{
int i;
double best_val; /* best population fitness */
double avg; /* avg population fitness */
double stddev; /* std. deviation of population fitness */
double sum_square; /* sum of square for std. calc */
double square_sum; /* square of sum for std. calc */
double sum; /* total population fitness */
sum = 0.0;
sum_square = 0.0;
for (i = 0; i 《 POPSIZE; i++)
{
sum += population[i].fitness;
sum_square += population[i].fitness * population[i].fitness;
}
avg = sum/(double)POPSIZE;
square_sum = avg * avg * POPSIZE;
stddev = sqrt((sum_square - square_sum)/(POPSIZE - 1));
best_val = population[POPSIZE].fitness;
fprintf(galog, “\n%5d, %6.3f, %6.3f, %6.3f \n\n“, generation,
best_val, avg, stddev);
}
/**************************************************************/
/* Main function: Each generation involves selecting the best */
/* members, performing crossover & mutation and then */
/* evaluating the resulting population, until the terminating */
/* condition is satisfied */
/**************************************************************/
void main(void)
{
int i;
if ((galog = fopen(“galog.txt“,“w“))==NULL)
{
exit(1);
}
generation = 0;
fprintf(galog, “\n generation best average standard \n“);
fprintf(galog, “ number value fitness deviation \n“);
initialize();
evaluate();
keep_the_best();
while(generation《MAXGENS)
{
generation++;
select();
crossover();
mutate();
report();
evaluate();
elitist();
}
fprintf(galog,“\n\n Simulation completed\n“);
fprintf(galog,“\n Best member: \n“);
for (i = 0; i 《 NVARS; i++)
{
fprintf (galog,“\n var(%d) = %3.3f“,i,population[POPSIZE].gene[i]);
}
fprintf(galog,“\n\n Best fitness = %3.3f“,population[POPSIZE].fitness);
fclose(galog);
printf(“Success\n“);
}
/***************************************************************/
遗传算法 算子有哪些
选择算子 一般随机选择 赌轮选择都可以
交叉算子 01编码的 ,传统的类似于基因串的交叉方式..
实数编码的.通常是 P(t+1,m) = aP(t,x)+(1-a)P(t,y) a∈(0,1)之间交叉,这个交叉方法基本上不收敛.我的经验是把a改成(0,2)之间收敛的效果很好.当然(0,1.75)～(0,2)之间的貌似都可以。具体原因我还在分析中。如果你有什么分析的结论的话，欢迎和我交流
变异算子 每代随便选一两个数某位变异一下就ok..
通过一个实例，叙述该混合遗传算法的基本思想是什么其基本构成原则是什么
您好，我看到您的问题很久没有人来回答，但是问题过期无人回答会被扣分的并且你的悬赏分也会被没收！所以我给你提几条建议：
一，你可以选择在正确的分类下去提问，这样知道你问题答案的人才会多一些，回答的人也会多些。
二，您可以到与您问题相关专业网站论坛里去看看，那里聚集了许多专业人才，一定可以为你解决问题的。
三，你可以向你的网上好友问友打听，他们会更加真诚热心为你寻找答案的，甚至可以到相关网站直接搜索.
四，网上很多专业论坛以及知识平台，上面也有很多资料，我遇到专业性的问题总是上论坛求解决办法的。
五，将你的问题问的细一些，清楚一些！让人更加容易看懂明白是什么意思!
谢谢采纳我的建议! !
-遗传算法经典实例
如何用遗传算法来处理多约束求相关的例题说明
处理多约束问题，一般用两种方法，一种是在生成初始个体时只生成满足约束的个体，即对个体的结构进行控制；二是通过惩罚函数，对不满足约束的个体加以惩罚。
遗传算法中常用的适应度函数是什么呢
1.物竞――适应度函数（fitness function）
自然界生物竞争过程往往包含两个方面：生物相互间的搏斗与及生物与客观环境的搏斗过程。但在我们这个实例里面，你可以想象到，袋鼠相互之间是非常友好的，它们并不需要互相搏斗以争取生存的权利。它们的生死存亡更多是取决于你的判断。因为你要衡量哪只袋鼠该杀，哪只袋鼠不该杀，所以你必须制定一个衡量的标准。而对于这个问题，这个衡量的标准比较容易制定：袋鼠所在的海拔高度。（因为你单纯地希望袋鼠爬得越高越好。）所以我们直接用袋鼠的海拔高度作为它们的适应性评分。即适应度函数直接返回函数值就行了。-遗传算法
引自：网页链接
求利用遗传算法实现矩形件排样 的VC编程案例
变异算子
从遗传算法的观点来看，解的进化主要是靠选择机制和交叉策略来完成，变异只是产生
新个体的辅助方法， 它决定了遗传算法的局部搜索能力。交叉算子和变异算子相互配合，
共同完成对搜索空间的全局搜索和局部搜索， 从而使遗传算法能够以良好的搜索性能完成
最优化问题的寻优过程，变异概率一般取为0.0001~0.1。变异算子一般采用旋转变异或位置
变异，设要排放的零件总数为n。
旋转变异的思想是产生[1，n]之间的一个随机数num，将该数取其相反数。
例如：产生的随机数 num=5
染色体为：A=｛ -3 ， 5 ， 7 ，-1 ， 6 ， 8 ，-2 ， 4｝
变异后的结果为：A’=｛ -3 ， 5 ， 7 ，-1 ，-6， 8 ，-2 ， 4｝
位置变异的思想是产生[1，n]之间的两个随机数num1、num2，将两个位置颠倒。
例如：产生的随机数 num1=3，num2=6
染色体为：A=｛ -3 ， 5 ， 7 ，-1 ， 6 ， 8 ，-2 ， 4｝
变异后的结果为：A’=｛ -3 ， 5 ， 8 ，-1 ，6，7 ，-2 ， 4｝
2. 6 适应度函数
适应度函数定义的好坏对问题的求解效果有很大影响。常见的定义适应度函数的方法有
两种:一种从排样图的最大高度方面考虑，要求尽量使排样图的最大高度值小，一般用最大
高度值的倒数来表示。另一种是从废料再利用的角度进行考虑的，要求尽可能的提高可再利
用废料的利用率(可再利用废料是指处于排样图最高轮廓线和排样图最大高度水平线之间的
部分)。针对板材的两种情况，分别定义了不同的适应度函数，假设排入的矩形件的总面积
为area1。
（1） 定宽无限长的板材情况
对于定宽无限长的板材，一般用排样高度来评价排样的优劣，适应度函数如下：
Fitness area1
h w
=
×
其中，h 为排样图的最大高度，w 为板材的宽度。
（2） 定宽定长的板材情况
这种情况下的适应度函数如下：
1
2
Fitness area
area h w
=
+ ×
其中，area2 为去掉最后一张板材的总面积，h 为最后一张板材的排样图的最大高度，w 为
选择算子采用最优保存策略，即把当前群体中适应度最高的个体不
-遗传算法经典实例
智能算法30个案例分析这本书关于遗传算法的程序解释
《matlab智能算法30个案例分析》(作者史峰、王辉、郁磊、胡斐)是作者多年从事算法研究的经验总结。书中所有案例均因国内各大matlab技术论坛网友的切身需求而精心设计，其中不少案例所涉及的内容和求解方法在国内现已出版的matlab书籍中鲜有介绍。
-遗传算法
