【随手拍小程序下载源码】【毒蛇源码】【源码11001101】遗传算法源码_遗传算法源码是什么

时间:2024-12-26 03:03:04 分类:最新挖矿源码 来源:酷喵影视源码

1.10分钟搞懂遗传算法(含源码)
2.带你解读遗传算法gplearn源码(第一次录讲代码的遗传源码遗传源码视频)
3.请问哪位有模拟退火遗传算法的源程序?

遗传算法源码_遗传算法源码是什么

10分钟搞懂遗传算法(含源码)

       大自然中存在一种神奇的力量,它能够将优良的算法算法基因保留下来,进而进化出更加强大、遗传源码遗传源码更适应生存的算法算法基因。这种力量启发了遗传算法的遗传源码遗传源码诞生,它模拟了自然选择、算法算法随手拍小程序下载源码物竞天择、遗传源码遗传源码适者生存的算法算法原则,通过多代的遗传源码遗传源码遗传、变异、算法算法交叉和复制,遗传源码遗传源码最终进化出问题的算法算法最优解。尽管遗传算法看起来神奇,遗传源码遗传源码但其实现思路相对简单。算法算法本文将介绍遗传算法的遗传源码遗传源码毒蛇源码基本思想,并运用遗传算法解决实际问题,最后给出遗传算法的代码实现和解析。

       在介绍遗传算法之前,我们需要了解以下几个概念:

       1. 基因和染色体:在遗传算法中,我们将要解决的问题映射成一个数学问题,一个可行解被称为一条“染色体”。一个可行解通常由多个元素构成,每个元素被称为染色体上的一个“基因”。

       2. 适应度函数:适应度函数在遗传算法中扮演着“上帝”的角色,用于衡量染色体的优劣。在迭代过程中,适应度函数会给所有染色体打分,评判其适应度,淘汰适应度较低的源码11001101染色体,保留适应度较高的染色体。

       3. 交叉:每次迭代都会生成N条染色体,这被称为一次“进化”。交叉的过程类似于交配,需要从上一代的染色体中选取两条染色体,然后拼接在一起,生成一条新的染色体。

       4. 变异:交叉可以保证每次进化留下优良的基因,但只能保证结果更接近局部最优解。为了解决这一问题,我们需要引入变异,即在新的染色体上随机修改基因的值,引入新的基因,突破当前搜索的envato源码限制。

       5. 复制:每次进化中,为了保留上一代优良的染色体,需要将适应度最高的几条染色体直接复制给下一代。

       遗传算法的执行流程如下:

       1. 生成初始染色体种群。

       2. 计算每个染色体的适应度。

       3. 根据适应度选择染色体进行交叉和变异。

       4. 生成新一代染色体种群。

       5. 重复步骤2-4,直到满足终止条件。

       在实际应用中,可以通过限定进化次数或允许范围来控制算法的迭代次数。选择何种方式取决于具体的业务场景。

       下面我们以负载均衡调度问题为例,介绍遗传算法的lzw源码解决方法。

       1. 数学建模:首先,我们需要将实际问题映射成遗传算法的数学模型,包括任务长度矩阵、节点处理速度矩阵、任务处理时间矩阵等。

       2. 染色体:染色体用于记录每次进化过程中的可行解,每个染色体由多个基因组成,每个基因表示将任务分配给节点的方案。

       3. 适应度矩阵:适应度矩阵记录每条染色体的适应度,用于评判染色体的优劣。

       4. 选择概率矩阵:选择概率矩阵记录每条染色体在下一次进化中被选择的概率,用于选择染色体进行交叉和变异。

       5. 遗传算法的实现:通过交叉、变异和复制等操作,生成新一代染色体种群,并不断迭代,直到满足终止条件。

       结果展示:通过遗传算法解决负载均衡调度问题,经过次进化,算法最终收敛于最优解。

带你解读遗传算法gplearn源码(第一次录讲代码的视频)

       遗传算法通过模拟生物进化过程,将基因突变、选择等机制应用于程序中,广泛应用于量价因子挖掘。

       遗传算法能帮我们挖掘现有因子的衍生潜力,生成新因子以增强预测准确性。以OBV指标为例,遗传算法可生成OBVM,即OBV的移动平均值,从而在预测上表现更优。

       遗传算法通过迭代过程生成新因子,但有时新因子不如旧因子,为解决此问题,可在每轮迭代后筛选优秀父代,让其直接进入下一代,不再参与迭代。

       算法自带算子有限,可加入更多函数,如talib的函数或从github获取的其他函数。同时,需注意输入输出处理,避免使用无效表达式。

       init_depth限制初始表达式长度,但无法控制最终长度,防止过拟合。监测fitness和公式长度,以避免产出冗长的过拟合公式。

       适应度函数评估因子维度有限,单一相关性检验会导致产出因子同质化。遗传算法是生成因子的强大工具,掌握其应用能提升因子竞争力。

       遗传算法在因子挖掘领域的应用,标志着从手工搓因子到量产因子的转变,掌握更多量产工具,将使我们在因子层面上更具竞争力。

请问哪位有模拟退火遗传算法的源程序?

       遗传算法求解f(x)=xcosx+2的最大值

       其中在尺度变换部分应用到了类似模拟退火算法部分,所有变量均使用汉语拼音很好懂

       //中国电子科技集团公司

       //第一研究室

       //呼文韬

       //hu_hu@.com

       //随机初始种群

       //编码方式为格雷码

       //选择方法为随机遍历

       //采用了精英保存策略

       //采用了自适应的交叉率和变异率

       //采用了与模拟退火算法相结合的尺度变换

       //采用了均匀交叉法

       #include <stdlib.h>

       #include <stdio.h>

       #include <math.h>

       #include <iostream.h>

       #include <iomanip.h>

       #include <time.h>

       #include <windows.h>

       #define IM1

       #define IM2

       #define AM (1.0/IM1)

       #define IMM1 (IM1-1)

       #define IA1

       #define IA2

       #define IQ1

       #define IQ2

       #define IR1

       #define IR2

       #define NTAB

       #define NDIV (1+IMM1/NTAB)

       #define EPS 1.2e-7

       #define RNMX (1.0-EPS)

       #define zhizhenjuli 0.

       #define PI 3.

       #define T0 //温度要取得很高才行。

       #define zhongqunshu1

       #define zuobianjie -

       #define youbianjie

       unsigned int seed=0; //seed 为种子,要设为全局变量

       void mysrand(long int i) //初始化种子

       {

       seed = -i;

       }

       long a[1];

       //double hundun;

       //double c=4;

       //设置全局变量

       struct individual

       {

       unsigned *chrom; //染色体;

       double geti;//变量值

       double shiyingdu; //目标函数的值;

       double fitness; //变换后的适应度值;

       };

       individual *zuiyougeti;//精英保存策略

       int zhongqunshu; //种群大小

       individual *nowpop;//当前代

       individual *newpop;//新一代

       double sumfitness;//当代的总适应度fitness

       double sumshiyingdu;//当代的总适应度shiyingdu

       double maxfitness;//最大适应度

       double avefitness;//平均适应度

       double maxshiyingdu;//最大适应度

       double avgshiyingdu;//平均适应度

       float pc;//交叉概率

       float pm;//变异概率

       int lchrom;//染色体长度

       int maxgen;//最大遗传代数

       int gen;//遗传代数

       //函数

       int flipc(double ,double );//判断是否交叉

       int flipm(double );//判断是否变异

       int rnd(int low,int high);//产生low与high之间的任意数

       void initialize();//遗传算法初始化

       void preselectfitness(); //计算sumfiness,avefitness,maxfitness

       void generation();

       double suijibianli();//产生随机遍历指针

       int fuzhi(float );//选择要复制的个体

       void crossover(individual ,individual ,individual &,individual &);//交叉

       void bianyi(individual &);//变异

       void mubiaohanshu(individual &);//计算适应度

       void chidubianhuan(individual &);//对shiyingdu进行尺度变换赋给fitness

       double ran1(long *);//随机数初始

       void bianma(double bianliang,unsigned *p);//编码

       double yima(unsigned *p);

       void guanjiancanshujisuan();//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness,avefitness,maxfitness

       void jingyingbaoliu();

       void glp(int n,int s,int *,int (*)[1],float (*)[1]);//glp生成函数

       BOOL Exist(int Val, int Num, int *Array);//判断一个数在前面是否出现过

       int cmpfitness(const void *p1,const void *p2)

       {

       float i=((individual *)p1)->shiyingdu;//现在是按照"适应度"排序,改成"个体"的话就是按照"个体"排序

       float j=((individual *)p2)->shiyingdu;

       return i<j ? -1:(i==j ? 0:1);//现在是按升序牌排列,将1和-1互换后就是按降序排列

       }

       void main()

       {

       initialize();

       cout<<zuiyougeti->geti<<" "<<zuiyougeti->shiyingdu<<endl;/////////////

       for(gen=1;gen<maxgen;gen++)

       { generation();

       }

       jingyingbaoliu();

       cout<<setiosflags(ios::fixed)<<setprecision(6)<<zuiyougeti->geti<<" "<<setiosflags(ios::fixed)<<setprecision(6)<<(zuiyougeti->shiyingdu)<<endl;////////////////

       delete [] newpop;

       delete [] nowpop;

       delete [] zuiyougeti;

       system("pause");

       }

       void initialize()

       {

       int q[zhongqunshu1][1],s=1;

       float xx[zhongqunshu1][1];//生成的glp用x储存

       int h[1]={ 1};//生成向量

       zuiyougeti=new individual;//最优个体的生成

       zhongqunshu=;//种群数量

       nowpop=new individual[zhongqunshu1];//当代

       newpop=new individual[zhongqunshu1];//新一代

       maxgen=;//最大代数

       gen=0;//起始代

       lchrom=;//基因数量的初始化

       mysrand(time(0));//随机数种子

       a[0]=seed;//随机数种子

       //对最优个体的初始化

       zuiyougeti->geti=0;

       zuiyougeti->fitness=0;

       zuiyougeti->shiyingdu=0;

       //

       glp(zhongqunshu,s,h,q,xx);

       //for(int i=0;i<zhongqunshu1;i++)//产生初始种群

       //{

       // for(int j=0;j<s;j++)

       // {

       // nowpop[i].geti=zuobianjie+(youbianjie-zuobianjie)*xx[i][j];

       // }

       //}

       for(int i=0;i<zhongqunshu1;i++)//产生初始种群

       {

       nowpop[i].geti=zuobianjie+(youbianjie-(zuobianjie))*ran1(a);

       }

       //nowpop[0].geti=;//////////////////////////

       guanjiancanshujisuan();

       jingyingbaoliu(); //精英保留的实现

       guanjiancanshujisuan();//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness,avefitness,maxfitness

       }

       void jingyingbaoliu() //精英保留的实现

       {

       individual *zuiyougetiguodu;

       zuiyougetiguodu=new individual[zhongqunshu1];//建立一个过渡数组

       for(int i=0;i<zhongqunshu;i++)//将当代个体复制到过渡数组中

       zuiyougetiguodu[i]=nowpop[i];

       qsort(zuiyougetiguodu,zhongqunshu1,sizeof(individual),&cmpfitness);//按fitness升序排序

       // cout<<"zuiyougetiguodu适应度:"<<zuiyougetiguodu[zhongqunshu1-1].shiyingdu<<endl;///////////

       // cout<<"zuiyougeti适应度:"<<zuiyougeti->shiyingdu<<endl;///////////////////

       //system("pause");

       if(zuiyougetiguodu[zhongqunshu-1].shiyingdu>zuiyougeti->shiyingdu)

       {

       *zuiyougeti=zuiyougetiguodu[zhongqunshu1-1];//如果最优个体的fitness比当代最大的fitness小则用当代的代替之

       //cout<<"zuiyougetiguodu个体:"<<zuiyougetiguodu[zhongqunshu1-1].geti<<endl;/////////////

       //cout<<"zuiyougeti个体:"<<zuiyougeti->geti<<endl;/////////////

       }

       else

       nowpop[rnd(0,(zhongqunshu1-1))]=*zuiyougeti;//否则的话从当代中随机挑选一个用最优个体代替之

       delete [] zuiyougetiguodu;//释放过渡数组

       }

       void guanjiancanshujisuan()//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness,avefitness,maxfitness

       {

       for(int i=0;i<zhongqunshu;i++)//计算shiyingdu

       mubiaohanshu(nowpop[i]);

       for(i=0;i<zhongqunshu;i++)//对shiyingdu进行尺度变换变成fitness

       chidubianhuan(nowpop[i]);

       preselectfitness();//根据fitness计算sumfitness,avefitness,maxfitness

       }

       void mubiaohanshu(individual &bianliang)//计算shiyingdu

       {

       bianliang.shiyingdu=(bianliang.geti*cos(bianliang.geti)+2.0);//目标函数

       }

       void chidubianhuan(individual &bianliang)//对shiyingdu进行尺度变换变成fitness

       {

       double T;//退火温度

       T=T0*(pow(0.,(gen+1-1)));

       double sum=0;

       for(int j=0;j<zhongqunshu;j++)

       sum+=exp(nowpop[j].shiyingdu/T);

       bianliang.fitness=exp(bianliang.shiyingdu/T)/sum;//算出fitness

       }

       void preselectfitness()//根据fitness计算sumfitness,avefitness,maxfitness

       {

       int j;

       sumfitness=0;

       for(j=0;j<zhongqunshu;j++)

       sumfitness+=nowpop[j].fitness;

       individual *guodu;

       guodu=new individual[zhongqunshu1];

       for(j=0;j<zhongqunshu;j++)

       guodu[j]=nowpop[j];

       qsort(guodu,zhongqunshu1,sizeof(individual),&cmpfitness);

       maxfitness=guodu[zhongqunshu1-1].fitness;

       avefitness=sumfitness/zhongqunshu1;

       delete [] guodu;

       }

       void generation()

       {

       individual fuqin1,fuqin2,*pipeiguodu,*pipeichi;

       int *peiduishuzu;//用来存放产生的随机配对

       pipeiguodu=new individual[zhongqunshu1];

       pipeichi=new individual[zhongqunshu1];

       peiduishuzu=new int[zhongqunshu1];

       int member1,member2,j=0,fuzhijishu=0,i=0,temp=0,tt=0;

       float zhizhen;

       //随机遍历的实现

       for(zhizhen=suijibianli();zhizhen<1;(zhizhen=zhizhen+zhizhenjuli))//设定指针1/

       {

       pipeichi[fuzhijishu]=nowpop[fuzhi(zhizhen)];

       fuzhijishu++;

       }

       //交叉与变异的实现

       //交叉

       for(i=0;i<zhongqunshu1;i++)

       {

       peiduishuzu[i]=-1;

       }

       for (i=0; i<zhongqunshu1; i++)

       {

       temp =rnd(0,zhongqunshu1-1); //产生值在0-zhongqunshu1-1的随机数

       while(Exist(temp, i, peiduishuzu))//判断产生的随机数是否已经产生过,如果是,则再产生一个随机数

       {

       temp =rnd(0,zhongqunshu1-1);

       }

       //如果没有的话,则把产生的随机数放在peiduishuzu中

       *(peiduishuzu+i) = temp;

       }

       for(i=0;i<zhongqunshu1-1;i=i+2)

       {

       fuqin1=pipeichi[peiduishuzu[i]];

       fuqin2=pipeichi[peiduishuzu[i+1]];

       crossover(fuqin1,fuqin2,newpop[i],newpop[i+1]);

       }

       for(j=0;j<zhongqunshu1;j++)

       {

       //if(newpop[j].geti<-)

       //cout<<"个体数值小于下界了";

       nowpop[j].geti=newpop[j].geti;

       }

       //

       guanjiancanshujisuan();

       //变异的实现

       for(j=0;j<zhongqunshu;j++)

       {

       bianyi(nowpop[j]);

       }

       //

       guanjiancanshujisuan();

       //精英保留的实现

       jingyingbaoliu();

       //

       guanjiancanshujisuan();

       delete [] peiduishuzu;

       delete [] pipeichi;

       delete [] pipeiguodu;

       }

       void crossover(individual parent1,individual parent2,individual &child1,individual &child2)//交叉

       {

       int j;

       unsigned *panduan;

       panduan=new unsigned[lchrom];

       parent1.chrom=new unsigned[lchrom];

       parent2.chrom=new unsigned[lchrom];

       child1.chrom=new unsigned[lchrom];

       child2.chrom=new unsigned[lchrom];

       //cout<<"jiaocha"<<endl;///////////////////////

       bianma(parent1.geti,parent1.chrom);

       bianma(parent2.geti,parent2.chrom);

       if(flipc(parent1.fitness,parent2.fitness))

       {

       for(j=0;j<lchrom;j++)

       panduan[j]=rnd(0,1);

       //for(j=0;j<lchrom;j++)////////////////

       // {

       // cout<<panduan[j];/////////////

       // }

       // cout<<endl;////////////////

       // system("pause");////////////////

       for(j=0;j<lchrom;j++)

       {

       if(panduan[j]==1)

       child1.chrom[j]=parent1.chrom[j];

       else

       child1.chrom[j]=parent2.chrom[j];

       }

       for(j=0;j<lchrom;j++)

       {

       if(panduan[j]==0)

       child2.chrom[j]=parent1.chrom[j];

       else

       child2.chrom[j]=parent2.chrom[j];

       }

       //for(j=0;j<lchrom;j++)////////////////

       //{

       // cout<<child1.chrom[j];/////////////

       // }

       //cout<<endl;////////////////

       // system("pause");////////////////

       child1.geti=yima(child1.chrom);

       child2.geti=yima(child2.chrom);

       delete [] child2.chrom;

       delete [] child1.chrom;

       delete [] parent2.chrom;

       delete [] parent1.chrom;

       delete [] panduan;

       }

       else

       {

       for(j=0;j<lchrom;j++)

       {

       child1.chrom[j]=parent1.chrom[j];

       child2.chrom[j]=parent2.chrom[j];

       }

       child1.geti=yima(child1.chrom);

       child2.geti=yima(child2.chrom);

       delete [] child2.chrom;

       delete [] child1.chrom;

       delete [] parent2.chrom;

       delete [] parent1.chrom;

       delete [] panduan;

       }

       }

       void bianyi(individual &child)//变异

       {

       child.chrom=new unsigned[lchrom];

       //cout<<"变异"<<endl;

       bianma(child.geti,child.chrom);

       for(int i=0;i<lchrom;i++)

       if(flipm(child.fitness))

       {

       if(child.chrom[i]=0)

       child.chrom[i]=1;

       else

       child.chrom[i]=0;

       }

       child.geti=yima(child.chrom);

       delete [] child.chrom;

       }

       void bianma(double bianliang,unsigned *p)//编码

       {

       unsigned *q;

       unsigned *gray;

       q=new unsigned[lchrom];

       gray=new unsigned[lchrom];

       int x=0;

       int i=0,j=0;

       if(bianliang<zuobianjie)///////////////////

       {

       cout<<"bianliang:"<<bianliang<<endl;/////////

       system("pause");

       }

       //cout<<youbianjie-(zuobianjie)<<endl;

       //system("pause");

       x=(bianliang-(zuobianjie))*((pow(2,lchrom)-1)/(youbianjie-(zuobianjie)));

       //cout<<x<<endl;///////////

       if(x<0)

       system("pause");///////////

       for(i=0;i<lchrom;i++)

       {

       q[i]=0;

       p[i]=0;

       }

       i=0;

       while (x!=0&&(i!=lchrom))

       {

       q[i]=(unsigned)(x%2);

       x=x/2;

       i++;

       }

       // for(i=0;i<lchrom;i++)//////////////////

       // cout<<q[i];///////////////

       // cout<<endl;///////////

       int w=lchrom-1;

       if(q[w]!=0&&q[w]!=1)

       system("pause");

       for(j=0;j<lchrom&&w>0;j++)

       {

       p[j]=q[w];

       w--;

       }

       //cout<<"yuanma"<<endl;

       //for(j=0;j<lchrom;j++)///////////

       // cout<<p[j];////////

       //cout<<endl;////////////////////

       gray[0]=p[0];

       for(j=1;j<lchrom;j++)

       {

       if(p[j-1]==p[j])

       gray[j]=0;

       else if(p[j-1]!=p[j])

       gray[j]=1;

       }

       for(j=0;j<lchrom;j++)

       p[j]=gray[j];

       //cout<<"geleima"<<endl;

       //for(j=0;j<lchrom;j++)///////////

       // cout<<p[j];////////

       //cout<<endl;////////////////////

       //system("pause");///////////

       delete [] gray;

       delete [] q;

       }

       double yima(unsigned *p) //译码

       {

       int i=0;

       // for(i=0;i<lchrom;i++)/////////

       // {

       // cout<<p[i];//////

       // }

       // cout<<endl;/////////

       // system("pause");//////////

       int x=0;

       unsigned *q;

       q=new unsigned[lchrom];

       q[0]=p[0];

       // cout<<q[0]<<endl;//////////////////

       // system("pause");//////////

       for(int j=1;j<lchrom;j++)

       {

       if(q[j-1]==p[j])

       q[j]=0;

       else if(q[j-1]!=p[j])

       q[j]=1;

       }

       // for(i=0;i<lchrom;i++)//////

       // {

       // cout<<q[i];//////////

       // if(q[i]!=0&&q[i]!=1)

       // {

       // cout<<q[i];

       // system("pause");

       // }

       // }

       // cout<<endl;////////

       // system("pause");///////////////////

       for(i=0;i<lchrom;i++)

       x=x+q[i]*pow(2,(lchrom-i-1));

       if(x<0)

       {

       cout<<"译码出错1"<<endl;

       system("pause");

       }

       //cout<<"x:"<<x<<endl;

       double bianliang;

       //cout<<pow(2,)<<endl;

       //cout<<*x<<endl;

       //cout<<(x*(/(pow(2,)-1)))<<endl;

       bianliang=(x*((youbianjie-(zuobianjie))/(pow(2,lchrom)-1)))+zuobianjie;

       if(bianliang<zuobianjie)

       {

       cout<<"译码出错2"<<endl;

       system("pause");

       }

       delete [] q;

       return bianliang;

       }

       double ran1(long *idum)

       {

       int j;

       long k;

       static long idum2=;

       static long iy=0;

       static long iv[NTAB];

       float temp;

       if (*idum <= 0)

       {

       if (-(*idum) < 1) *idum=1;

       else *idum = -(*idum);

       idum2=(*idum);

       for (j=NTAB+7;j>=0;j--)

       {

       k=(*idum)/IQ1;

       *idum=IA1*(*idum-k*IQ1)-k*IR1;

       if (*idum < 0) *idum += IM1;

       if (j < NTAB) iv[j] = *idum;

       }

       iy=iv[0];

       }

       k=(*idum)/IQ1;

       *idum=IA1*(*idum-k*IQ1)-k*IR1;

       if (*idum < 0) *idum += IM1;

       k=idum2/IQ2;

       idum2=IA2*(idum2-k*IQ2)-k*IR2;

       if (idum2 < 0) idum2 += IM2;

       j=iy/NDIV;

       iy=iv[j]-idum2;

       iv[j] = *idum;

       if (iy < 1) iy += IMM1;

       if ((temp=AM*iy) > RNMX) return RNMX;

       else return temp;

       }

       double suijibianli()//随机遍历

       {

       double i=ran1(a);

       while(i>zhizhenjuli)

       {

       i=ran1(a);

       }

       //cout<<i<<endl;//////////////

       return i;

       }

       int fuzhi(float p)//复制

       {

       int i;

       double sum=0;

       if(sumfitness!=0)

       {

       for(i=0;(sum<p)&&(i<zhongqunshu);i++)

       sum+=nowpop[i].fitness/sumfitness;

       }

       else

       i=rnd(1,zhongqunshu1);

       return(i-1);

       }

       int rnd(int low, int high) /*在整数low和high之间产生一个随机整数*/

       {

       int i;

       if(low >= high)

       i = low;

       else

       {

       i =(int)((ran1(a) * (high - low + 1)) + low);

       if(i > high) i = high;

       }

       return(i);

       }

       int flipc(double p,double q)//判断是否交叉

       {

       double pc1=0.9,pc2=0.6;

       if((p-q)>0)

       {

       if(p>=avefitness)

       {

       pc=pc1-(pc1-pc2)*(p-avefitness)/(maxfitness-avefitness);

       }

       else

       pc=pc1;

       }

       else

       {

       if(q>=avefitness)

       {

       pc=pc1-(pc1-pc2)*(q-avefitness)/(maxfitness-avefitness);

       }

       else

       pc=pc1;

       }

       if(ran1(a)<=pc)

       return(1);

       else

       return(0);

       }

       int flipm(double p)//判断是否变异

       {

       double pm1=0.,pm2=0.;

       if(p>=avefitness)

       {

       pm=(pm1-(pm1-pm2)*(maxfitness-p)/(maxfitness-avefitness));

       }

       else

       pm=pm1;

       if(ran1(a)<=pm)

       return(1);

       else

       return(0);

       }

       void glp(int n,int s,int *h,int (*q)[1],float (*xx)[1])//glp

       {

       int i=0,j=0;

       //求解q

       for(i=0;i<n;i++)

       {

       for(j=0;j<s;j++)

       {

       *(*(q+i)+j)=((i+1)*(*(h+j)))%n;

       }

       }

       i=n-1;

       for(j=0;j<s;j++)

       {

       *(*(q+i)+j)=n;

       }

       //求解x

       for(i=0;i<n;i++)

       {

       for(j=0;j<s;j++)

       {

       *(*(xx+i)+j)=(float)(2*(*(*(q+i)+j))-1)/(2*n);

       }

       }

       }

       BOOL Exist(int Val, int Num, int *Array)//判断一个数是否在一个数组的前Num个数中

       {

       BOOL FLAG = FALSE;

       int i;

       for (i=0; i<Num; i++)

       if (Val == *(Array + i))

       {

       FLAG = TRUE;

       break;

       }

       return FLAG;

       }