for(i=0i<12i++)
{
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=0y<wyy++)
for(x=0x<wxx++)
{
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=1i<G_LENGTHi++)
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=0i<wyi++)
for(j=0j<wxj++)
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=0i<numi++)
{
find_empty(&x,&y)
world[x][y]=4
}
num=(int)(size/5.0)
if(num>MAX_FOOD) num=MAX_FOOD
for(i=0i<numi++)
{
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=0y<wyy++)
for(x=0x<wxx++)
if(world[x][y]==0)
{
num=0
for(i=-1i<=1i++)
for(j=-1j<=1j++)
if(get_world(x+j,y+i)==4)
num++
if(num>=6) world[x][y]=4
}
/* 设定生物 */
num=(int)(size*R_LIFE)
for(i=0i<numi++)
{ find_empty(&x,&y)
world[x][y]=random(2)+1
}
/* 设定食物 */
num=(int)(size*R_FOOD)
for(i=0i<numi++)
{
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=0i<wyi++)
for(j=0j<wxj++)
fscanf(fpt,"%d",&world[j] [ i])
fclose(fpt)
一个非常简单的遗传算法源代码，是由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 = 0i <NVARSi++)
{
fscanf(infile, "%lf",&lbound)
fscanf(infile, "%lf",&ubound)
for (j = 0j <POPSIZEj++)
{
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 = 0mem <POPSIZEmem++)
{
for (i = 0i <NVARSi++)
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 = 0mem <POPSIZEmem++)
{
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 = 0i <NVARSi++)
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[0].fitness
worst = population[0].fitness
for (i = 0i <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 populationelse replace the */
/* worst individual from the current population with the */
/* best one from the previous generation */
if (best >= population[POPSIZE].fitness)
{
for (i = 0i <NVARSi++)
population[POPSIZE].gene[i] = population[best_mem].gene[i]
population[POPSIZE].fitness = population[best_mem].fitness
}
else
{
for (i = 0i <NVARSi++)
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 = 0mem <POPSIZEmem++)
{
sum += population[mem].fitness
}
/* calculate relative fitness */
for (mem = 0mem <POPSIZEmem++)
{
population[mem].rfitness = population[mem].fitness/sum
}
population[0].cfitness = population[0].rfitness
/* calculate cumulative fitness */
for (mem = 1mem <POPSIZEmem++)
{
population[mem].cfitness = population[mem-1].cfitness +
population[mem].rfitness
}
/* finally select survivors using cumulative fitness. */
for (i = 0i <POPSIZEi++)
{
p = rand()%1000/1000.0
if (p <population[0].cfitness)
newpopulation[i] = population[0]
else
{
for (j = 0j <POPSIZEj++)
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 = 0i <POPSIZEi++)
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 = 0mem <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 = 0i <pointi++)
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 = 0i <POPSIZEi++)
for (j = 0j <NVARSj++)
{
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 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 = 0i <NVARSi++)
{
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")
}
另外,虚机团上产品团购,超级便宜
#include <stdio.h>#include <math.h>
#include <stdlib.h>
#include <time.h>
float f(float x)
{
return x * x
}
void main()
{
float x[10]
float f1, f2
int i, j
float fmax
int xfmax
srand(time(NULL))
xfmax = 0
x[0] = 15.0f
f1 = f(x[0])
f2 = f1 + 1.0f
for (j = 0fabs(f1 - f2) >= 0.0001f || j <50j++)
{
for (i = 0i <10i++)
{
if (i != xfmax)
{
x[i] = -1
while (!(x[i] >= 0 &&x[i] <= 30))
{
x[i] = x[xfmax] + ((float)rand() / RAND_MAX * 2 - 1) * (15.0f / (j * 2 + 1))
}
}
}
xfmax = -1
for (i = 0i <10i++)
{
if (xfmax <0 || fmax <f(x[i]))
{
fmax = f(x[i])
xfmax = i
}
}
f2 = f1
f1 = fmax
}
printf("f(%f) = %f\n", x[xfmax], fmax)
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）