遗传算法的c语言程序

合集下载

遗传算法入门实例:对 PID 参数寻优

遗传算法入门实例:对 PID 参数寻优

遗传算法入门实例:对PID参数寻优[原创][这乌龟飙得好快啊]开始之前:假设你已经:能运用C语言,初步了解PID、遗传算法的原理。

遗传算法能干什么?(我有个毛病:每当遇到一个东东,我首先会设法知道:这个东东能干什么呢?)遗传算法可以解决非线性、难以用数学描述的复杂问题。

也许这样的陈述让你觉得很抽象,把它换成白话说就是:有个问题我不知道甚至不可能用数学的方法去推导、解算,那么也许我就可以用遗传算法来解决。

遗传算法的优点是:你不需要知道怎么去解决一个问题; 你需要知道的仅仅是,用怎么的方式对可行解进行编码,使得它能能被遗传算法机制所利用。

如果你运用过PID来控制某个系统,那你一定非常清楚:PID麻烦就在那三个参量的调整上,很多介绍PID的书上常搬一些已知数学模型的系统来做实例环节,但事实上我们面对的往往是不可能用数学模型描述的系统,这个时候该怎么取PID的参值呢?1、可以依靠经验凑试,耗时耗精力。

2、离线规划,这就是下文要做的事情3、在线规划,比方说神经网络PID(后续文章将推出,做个广告先^_^)。

一、 将PID用在本次试验中来个问题先:A VR怎样利用片上和少量的外围器件快速准确地实现D/A输出?(0~5V)1、实验电路的搭建:图1:实验原理图搭建这样的电路纯粹是为了本次实验的直观(超调、调整不足等现象通过示波器一目了然),当然,如果实际工程这么简单那也用不到PID,更用不到遗传算法了。

回归话题,解释下上面的电路:M16单片机的OC2输出0~100%占空比的PWM,经过RC,可以得到0~5V 的直流电压,这就实现了简易的D/A(实际实验,发现输出电压是1.XX伏~4.XX 伏,未带负载)。

用一个图表示:这个时候如果我要输出 3.5V (可以是其它值)电压,该加怎样的PWM呢?(有个简单的方法:标定,但是这种方法系统调整响应速度较为缓慢,理由见图5下附言)也许我们可以把这个输出电压加到A/D反馈到系统,这样就形成了闭环控制:系统输出PWM ——>> PWM 转换成电压——>>A/D 采集,获得实际值与目标值的偏差(例如3.5V )——>>将偏差进行PID 加载到PWM 输出(然后输出又影响下一次的输入……)把示波器加到测试点上,调整扫描周期,使示波器能看到完整的一个调整过程。

基于C语言的遗传算法应用研究

基于C语言的遗传算法应用研究

基于C语言的遗传算法应用研究介绍遗传算法是一种受生物学启发的优化算法,通过模拟进化过程来寻找最优解。

它被广泛应用于解决各种复杂问题,如组合优化、函数优化、机器学习等领域。

在本文中,我们将讨论基于C语言的遗传算法的应用研究。

遗传算法的原理遗传算法的原理是基于自然选择和遗传机制。

它模拟了生物进化过程中的选择、复制和变异等操作。

算法通过对一个种群进行迭代操作来逐步优化解的质量,直到找到全局最优解或最优近似解。

遗传算法主要包含以下几个关键步骤: 1. 初始化种群:随机生成一组个体作为初始种群。

2. 评估适应度:根据问题的定义,对每个个体计算适应度值。

3.选择操作:根据适应度值选择优秀的个体作为父代。

4. 交叉操作:通过交叉操作,将父代的基因进行混合,生成新的子代。

5. 变异操作:对子代进行变异,引入新的基因信息。

6. 更新种群:用新的个体替代原来的个体,形成新的种群。

7. 终止条件:根据预先设定的终止条件,决定算法是否结束。

C语言在遗传算法中的应用C语言作为一种通用的高级编程语言,具有高效、灵活和可移植的特点,非常适合在遗传算法中实现。

以下是C语言在遗传算法中的几个关键应用。

种群表示C语言可以使用数组或结构体等数据结构来表示遗传算法的种群。

每个个体可以用一个固定长度的二进制串或其他数据类型来表示。

C语言提供了强大的数组操作功能,使得种群的处理和操作更加简便和高效。

适应度函数C语言可以定义适应度函数来评估每个个体的适应度值。

适应度函数根据问题的特定要求来计算一个个体的适应度值,作为选择操作的依据。

C语言提供了丰富的数学函数库,使得适应度函数的计算更加方便。

选择操作C语言可以使用多种选择算法来选择优秀的个体作为父代。

例如,可以使用轮盘赌选择、锦标赛选择等方法来实现选择操作。

C语言提供了条件语句和随机数生成等功能,使得选择操作的实现简单而灵活。

交叉操作C语言可以通过交叉操作将父代的基因混合,生成新的子代。

2020年遗传算法matlab程序实例精编版

2020年遗传算法matlab程序实例精编版

%-----------------------------------------------%---------------------------------------------------遗传算法程序(一):说明: fga.m 为遗传算法的主程序; 采用二进制Gray编码,采用基于轮盘赌法的非线性排名选择, 均匀交叉,变异操作,而且还引入了倒位操作!function [BestPop,Trace]=fga(FUN,LB,UB,eranum,popsize,pCross,pMutation,pInversion,options) % [BestPop,Trace]=fmaxga(FUN,LB,UB,eranum,popsize,pcross,pmutation)% Finds a maximum of a function of several variables.% fmaxga solves problems of the form:% max F(X) subject to: LB <= X <= UB% BestPop - 最优的群体即为最优的染色体群% Trace - 最佳染色体所对应的目标函数值% FUN - 目标函数% LB - 自变量下限% UB - 自变量上限% eranum - 种群的代数,取100--1000(默认200)% popsize - 每一代种群的规模;此可取50--200(默认100)% pcross - 交叉概率,一般取0.5--0.85之间较好(默认0.8)% pmutation - 初始变异概率,一般取0.05-0.2之间较好(默认0.1)% pInversion - 倒位概率,一般取0.05-0.3之间较好(默认0.2)% options - 1*2矩阵,options(1)=0二进制编码(默认0),option(1)~=0十进制编%码,option(2)设定求解精度(默认1e-4)%% ------------------------------------------------------------------------T1=clock;if nargin<3, error('FMAXGA requires at least three input arguments'); endif nargin==3, eranum=200;popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==4, popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==5, pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==6, pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==7, pInversion=0.15;options=[0 1e-4];endif find((LB-UB)>0)error('数据输入错误,请重新输入(LB<UB):');ends=sprintf('程序运行需要约%.4f 秒钟时间,请稍等......',(eranum*popsize/1000));disp(s);global m n NewPop children1 children2 VarNumbounds=[LB;UB]';bits=[];VarNum=size(bounds,1);precision=options(2);%由求解精度确定二进制编码长度bits=ceil(log2((bounds(:,2)-bounds(:,1))' ./ precision));%由设定精度划分区间[Pop]=InitPopGray(popsize,bits);%初始化种群[m,n]=size(Pop);NewPop=zeros(m,n);children1=zeros(1,n);children2=zeros(1,n);pm0=pMutation;BestPop=zeros(eranum,n);%分配初始解空间BestPop,TraceTrace=zeros(eranum,length(bits)+1);i=1;while i<=eranumfor j=1:mvalue(j)=feval(FUN(1,:),(b2f(Pop(j,:),bounds,bits)));%计算适应度end[MaxValue,Index]=max(value);BestPop(i,:)=Pop(Index,:);Trace(i,1)=MaxValue;Trace(i,(2:length(bits)+1))=b2f(BestPop(i,:),bounds,bits);[selectpop]=NonlinearRankSelect(FUN,Pop,bounds,bits);%非线性排名选择[CrossOverPop]=CrossOver(selectpop,pCross,round(unidrnd(eranum-i)/eranum));%采用多点交叉和均匀交叉,且逐步增大均匀交叉的概率%round(unidrnd(eranum-i)/eranum)[MutationPop]=Mutation(CrossOverPop,pMutation,VarNum);%变异[InversionPop]=Inversion(MutationPop,pInversion);%倒位Pop=InversionPop;%更新pMutation=pm0+(i^4)*(pCross/3-pm0)/(eranum^4);%随着种群向前进化,逐步增大变异率至1/2交叉率p(i)=pMutation;i=i+1;endt=1:eranum;plot(t,Trace(:,1)');title('函数优化的遗传算法');xlabel('进化世代数(eranum)');ylabel('每一代最优适应度(maxfitness)');[MaxFval,I]=max(Trace(:,1));X=Trace(I,(2:length(bits)+1));hold on; plot(I,MaxFval,'*');text(I+5,MaxFval,['FMAX=' num2str(MaxFval)]);str1=sprintf ('进化到%d 代,自变量为%s 时,得本次求解的最优值%f\n对应染色体是:%s',I,num2str(X),MaxFval,num2str(BestPop(I,:)));disp(str1);%figure(2);plot(t,p);%绘制变异值增大过程T2=clock;elapsed_time=T2-T1;if elapsed_time(6)<0elapsed_time(6)=elapsed_time(6)+60; elapsed_time(5)=elapsed_time(5)-1;endif elapsed_time(5)<0elapsed_time(5)=elapsed_time(5)+60;elapsed_time(4)=elapsed_time(4)-1;end %像这种程序当然不考虑运行上小时啦str2=sprintf('程序运行耗时%d 小时%d 分钟%.4f 秒',elapsed_time(4),elapsed_time(5),elapsed_time(6));disp(str2);%初始化种群%采用二进制Gray编码,其目的是为了克服二进制编码的Hamming悬崖缺点function [initpop]=InitPopGray(popsize,bits)len=sum(bits);initpop=zeros(popsize,len);%The whole zero encoding individualfor i=2:popsize-1pop=round(rand(1,len));pop=mod(([0 pop]+[pop 0]),2);%i=1时,b(1)=a(1);i>1时,b(i)=mod(a(i-1)+a(i),2)%其中原二进制串:a(1)a(2)...a(n),Gray串:b(1)b(2)...b(n)initpop(i,:)=pop(1:end-1);endinitpop(popsize,:)=ones(1,len);%The whole one encoding individual%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%解码function [fval] = b2f(bval,bounds,bits)% fval - 表征各变量的十进制数% bval - 表征各变量的二进制编码串% bounds - 各变量的取值范围% bits - 各变量的二进制编码长度scale=(bounds(:,2)-bounds(:,1))'./(2.^bits-1); %The range of the variablesnumV=size(bounds,1);cs=[0 cumsum(bits)];for i=1:numVa=bval((cs(i)+1):cs(i+1));fval(i)=sum(2.^(size(a,2)-1:-1:0).*a)*scale(i)+bounds(i,1);end%选择操作%采用基于轮盘赌法的非线性排名选择%各个体成员按适应值从大到小分配选择概率:%P(i)=(q/1-(1-q)^n)*(1-q)^i, 其中P(0)>P(1)>...>P(n), sum(P(i))=1function [selectpop]=NonlinearRankSelect(FUN,pop,bounds,bits)global m nselectpop=zeros(m,n);fit=zeros(m,1);for i=1:mfit(i)=feval(FUN(1,:),(b2f(pop(i,:),bounds,bits)));%以函数值为适应值做排名依据endselectprob=fit/sum(fit);%计算各个体相对适应度(0,1)q=max(selectprob);%选择最优的概率x=zeros(m,2);x(:,1)=[m:-1:1]';[y x(:,2)]=sort(selectprob);r=q/(1-(1-q)^m);%标准分布基值newfit(x(:,2))=r*(1-q).^(x(:,1)-1);%生成选择概率newfit=cumsum(newfit);%计算各选择概率之和rNums=sort(rand(m,1));fitIn=1;newIn=1;while newIn<=mif rNums(newIn)<newfit(fitIn)selectpop(newIn,:)=pop(fitIn,:);newIn=newIn+1;elsefitIn=fitIn+1;endend%交叉操作function [NewPop]=CrossOver(OldPop,pCross,opts)%OldPop为父代种群,pcross为交叉概率global m n NewPopr=rand(1,m);y1=find(r<pCross);y2=find(r>=pCross);len=length(y1);if len>2&mod(len,2)==1%如果用来进行交叉的染色体的条数为奇数,将其调整为偶数y2(length(y2)+1)=y1(len);y1(len)=[];endif length(y1)>=2for i=0:2:length(y1)-2if opts==0[NewPop(y1(i+1),:),NewPop(y1(i+2),:)]=EqualCrossOver(OldPop(y1(i+1),:),OldPop(y1(i+2),:));else[NewPop(y1(i+1),:),NewPop(y1(i+2),:)]=MultiPointCross(OldPop(y1(i+1),:),OldPop(y1(i+2),:));endendendNewPop(y2,:)=OldPop(y2,:);%采用均匀交叉function [children1,children2]=EqualCrossOver(parent1,parent2)global n children1 children2hidecode=round(rand(1,n));%随机生成掩码crossposition=find(hidecode==1);holdposition=find(hidecode==0);children1(crossposition)=parent1(crossposition);%掩码为1,父1为子1提供基因children1(holdposition)=parent2(holdposition);%掩码为0,父2为子1提供基因children2(crossposition)=parent2(crossposition);%掩码为1,父2为子2提供基因children2(holdposition)=parent1(holdposition);%掩码为0,父1为子2提供基因%采用多点交叉,交叉点数由变量数决定function [Children1,Children2]=MultiPointCross(Parent1,Parent2)global n Children1 Children2 VarNumChildren1=Parent1;Children2=Parent2;Points=sort(unidrnd(n,1,2*VarNum));for i=1:VarNumChildren1(Points(2*i-1):Points(2*i))=Parent2(Points(2*i-1):Points(2*i));Children2(Points(2*i-1):Points(2*i))=Parent1(Points(2*i-1):Points(2*i));end%变异操作function [NewPop]=Mutation(OldPop,pMutation,VarNum)global m n NewPopr=rand(1,m);position=find(r<=pMutation);len=length(position);if len>=1for i=1:lenk=unidrnd(n,1,VarNum); %设置变异点数,一般设置1点for j=1:length(k)if OldPop(position(i),k(j))==1OldPop(position(i),k(j))=0;elseOldPop(position(i),k(j))=1;endendendendNewPop=OldPop;%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%倒位操作function [NewPop]=Inversion(OldPop,pInversion)global m n NewPopNewPop=OldPop;r=rand(1,m);PopIn=find(r<=pInversion);len=length(PopIn);if len>=1for i=1:lend=sort(unidrnd(n,1,2));if d(1)~=1&d(2)~=nNewPop(PopIn(i),1:d(1)-1)=OldPop(PopIn(i),1:d(1)-1);NewPop(PopIn(i),d(1):d(2))=OldPop(PopIn(i),d(2):-1:d(1));NewPop(PopIn(i),d(2)+1:n)=OldPop(PopIn(i),d(2)+1:n);endendend遗传算法程序(二):function youhuafunD=code;N=50; % Tunablemaxgen=50; % Tunablecrossrate=0.5; %Tunablemuterate=0.08; %Tunablegeneration=1;num = length(D);fatherrand=randint(num,N,3);score = zeros(maxgen,N);while generation<=maxgenind=randperm(N-2)+2; % 随机配对交叉A=fatherrand(:,ind(1:(N-2)/2));B=fatherrand(:,ind((N-2)/2+1:end));% 多点交叉rnd=rand(num,(N-2)/2);ind=rnd tmp=A(ind);A(ind)=B(ind);B(ind)=tmp;% % 两点交叉% for kk=1:(N-2)/2% rndtmp=randint(1,1,num)+1;% tmp=A(1:rndtmp,kk);% A(1:rndtmp,kk)=B(1:rndtmp,kk);% B(1:rndtmp,kk)=tmp;% endfatherrand=[fatherrand(:,1:2),A,B];% 变异rnd=rand(num,N);ind=rnd [m,n]=size(ind);tmp=randint(m,n,2)+1;tmp(:,1:2)=0;fatherrand=tmp+fatherrand;fatherrand=mod(fatherrand,3);% fatherrand(ind)=tmp;%评价、选择scoreN=scorefun(fatherrand,D);% 求得N个个体的评价函数score(generation,:)=scoreN;[scoreSort,scoreind]=sort(scoreN);sumscore=cumsum(scoreSort);sumscore=sumscore./sumscore(end);childind(1:2)=scoreind(end-1:end);for k=3:Ntmprnd=rand;tmpind=tmprnd difind=[0,diff(tmpind)];if ~any(difind)difind(1)=1;endchildind(k)=scoreind(logical(difind));endfatherrand=fatherrand(:,childind);generation=generation+1;end% scoremaxV=max(score,[],2);minV=11*300-maxV;plot(minV,'*');title('各代的目标函数值');F4=D(:,4);FF4=F4-fatherrand(:,1);FF4=max(FF4,1);D(:,5)=FF4;save DData Dfunction D=codeload youhua.mat% properties F2 and F3F1=A(:,1);F2=A(:,2);F3=A(:,3);if (max(F2)>1450)||(min(F2)<=900)error('DATA property F2 exceed it''s range (900,1450]')end% get group property F1 of data, according to F2 valueF4=zeros(size(F1));for ite=11:-1:1index=find(F2<=900+ite*50);F4(index)=ite;endD=[F1,F2,F3,F4];function ScoreN=scorefun(fatherrand,D)F3=D(:,3);F4=D(:,4);N=size(fatherrand,2);FF4=F4*ones(1,N);FF4rnd=FF4-fatherrand;FF4rnd=max(FF4rnd,1);ScoreN=ones(1,N)*300*11;% 这里有待优化for k=1:NFF4k=FF4rnd(:,k);for ite=1:11F0index=find(FF4k==ite);if ~isempty(F0index)tmpMat=F3(F0index);tmpSco=sum(tmpMat);ScoreBin(ite)=mod(tmpSco,300);endendScorek(k)=sum(ScoreBin);endScoreN=ScoreN-Scorek;%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%遗传算法程序(三):%IAGAfunction best=gaclearMAX_gen=200; %最大迭代步数best.max_f=0; %当前最大的适应度STOP_f=14.5; %停止循环的适应度RANGE=[0 255]; %初始取值范围[0 255]SPEEDUP_INTER=5; %进入加速迭代的间隔advance_k=0; %优化的次数popus=init; %初始化for gen=1:MAX_genfitness=fit(popus,RANGE); %求适应度f=fitness.f;picked=choose(popus,fitness); %选择popus=intercross(popus,picked); %杂交popus=aberrance(popus,picked); %变异if max(f)>best.max_fadvance_k=advance_k+1;x_better(advance_k)=fitness.x;best.max_f=max(f);best.popus=popus;best.x=fitness.x;endif mod(advance_k,SPEEDUP_INTER)==0RANGE=minmax(x_better);RANGEadvance=0;endendreturn;function popus=init%初始化M=50;%种群个体数目N=30;%编码长度popus=round(rand(M,N));return;function fitness=fit(popus,RANGE)%求适应度[M,N]=size(popus);fitness=zeros(M,1);%适应度f=zeros(M,1);%函数值A=RANGE(1);B=RANGE(2);%初始取值范围[0 255]for m=1:Mx=0;for n=1:Nx=x+popus(m,n)*(2^(n-1));endx=x*((B-A)/(2^N))+A;for k=1:5f(m,1)=f(m,1)-(k*sin((k+1)*x+k));endendf_std=(f-min(f))./(max(f)-min(f));%函数值标准化fitness.f=f;fitness.f_std=f_std;fitness.x=x;return;function picked=choose(popus,fitness)%选择f=fitness.f;f_std=fitness.f_std;[M,N]=size(popus);choose_N=3; %选择choose_N对双亲picked=zeros(choose_N,2); %记录选择好的双亲p=zeros(M,1); %选择概率d_order=zeros(M,1);%把父代个体按适应度从大到小排序f_t=sort(f,'descend');%将适应度按降序排列for k=1:Mx=find(f==f_t(k));%降序排列的个体序号d_order(k)=x(1);endfor m=1:Mpopus_t(m,:)=popus(d_order(m),:);endpopus=popus_t;f=f_t;p=f_std./sum(f_std); %选择概率c_p=cumsum(p)'; %累积概率for cn=1:choose_Npicked(cn,1)=roulette(c_p); %轮盘赌picked(cn,2)=roulette(c_p); %轮盘赌popus=intercross(popus,picked(cn,:));%杂交endpopus=aberrance(popus,picked);%变异return;function popus=intercross(popus,picked) %杂交[M_p,N_p]=size(picked);[M,N]=size(popus);for cn=1:M_pp(1)=ceil(rand*N);%生成杂交位置p(2)=ceil(rand*N);p=sort(p);t=popus(picked(cn,1),p(1):p(2));popus(picked(cn,1),p(1):p(2))=popus(picked(cn,2),p(1):p(2));popus(picked(cn,2),p(1):p(2))=t;endreturn;function popus=aberrance(popus,picked) %变异P_a=0.05;%变异概率[M,N]=size(popus);[M_p,N_p]=size(picked);U=rand(1,2);for kp=1:M_pif U(2)>=P_a %如果大于变异概率,就不变异continue;endif U(1)>=0.5a=picked(kp,1);elsea=picked(kp,2);endp(1)=ceil(rand*N);%生成变异位置p(2)=ceil(rand*N);if popus(a,p(1))==1%0 1变换popus(a,p(1))=0;elsepopus(a,p(1))=1;endif popus(a,p(2))==1popus(a,p(2))=0;elsepopus(a,p(2))=1;endendreturn;function picked=roulette(c_p) %轮盘赌[M,N]=size(c_p);M=max([M N]);U=rand;if U<c_p(1)picked=1;return;endfor m=1:(M-1)if U>c_p(m) & U<c_p(m+1)picked=m+1;break;endend全方位的两点杂交、两点变异的改进的加速遗传算法(IAGA)%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%。

遗传算法的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问题为例

遗传算法的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个解,依次类推。

遗传算法及其MATLAB程序代码

遗传算法及其MATLAB程序代码

遗传算法及其MATLAB程序代码遗传算法及其MATLAB实现主要参考书:MATLAB 6.5 辅助优化计算与设计飞思科技产品研发中⼼编著电⼦⼯业出版社2003.1遗传算法及其应⽤陈国良等编著⼈民邮电出版社1996.6主要内容:遗传算法简介遗传算法的MATLAB实现应⽤举例在⼯业⼯程中,许多最优化问题性质⼗分复杂,很难⽤传统的优化⽅法来求解.⾃1960年以来,⼈们对求解这类难解问题⽇益增加.⼀种模仿⽣物⾃然进化过程的、被称为“进化算法(evolutionary algorithm)”的随机优化技术在解这类优化难题中显⽰了优于传统优化算法的性能。

⽬前,进化算法主要包括三个研究领域:遗传算法、进化规划和进化策略。

其中遗传算法是迄今为⽌进化算法中应⽤最多、⽐较成熟、⼴为⼈知的算法。

⼀、遗传算法简介遗传算法(Genetic Algorithm, GA)最先是由美国Mic-hgan⼤学的John Holland于1975年提出的。

遗传算法是模拟达尔⽂的遗传选择和⾃然淘汰的⽣物进化过程的计算模型。

它的思想源于⽣物遗传学和适者⽣存的⾃然规律,是具有“⽣存+检测”的迭代过程的搜索算法。

遗传算法以⼀种群体中的所有个体为对象,并利⽤随机化技术指导对⼀个被编码的参数空间进⾏⾼效搜索。

其中,选择、交叉和变异构成了遗传算法的遗传操作;参数编码、初始群体的设定、适应度函数的设计、遗传操作设计、控制参数设定等5个要素组成了遗传算法的核⼼内容。

遗传算法的基本步骤:遗传算法是⼀种基于⽣物⾃然选择与遗传机理的随机搜索算法,与传统搜索算法不同,遗传算法从⼀组随机产⽣的称为“种群(Population)”的初始解开始搜索过程。

种群中的每个个体是问题的⼀个解,称为“染⾊体(chromos ome)”。

染⾊体是⼀串符号,⽐如⼀个⼆进制字符串。

这些染⾊体在后续迭代中不断进化,称为遗传。

在每⼀代中⽤“适值(fitness)”来测量染⾊体的好坏,⽣成的下⼀代染⾊体称为后代(offspring)。

用遗传算法求解多目标函数优化c++程序

用遗传算法求解多目标函数优化c++程序

遗传算法是一种优化搜索方法,它模拟了自然选择和遗传学中的一些概念,如基因突变、交叉和选择。

这种方法可以用于解决多目标优化问题,其中多个目标之间可能存在冲突。

以下是一个使用C++和OpenCV库实现遗传算法的基本示例。

这个例子解决的是一个简单的多目标优化问题,目标是找到一个最优的图像分割方案,使得两个目标(分割的精度和计算的效率)同时最大化。

注意:这个示例是为了演示遗传算法的基本概念,并不一定适用于所有问题。

你可能需要根据你的具体需求来调整遗传算法的参数和约束条件。

```cpp#include <iostream>#include <vector>#include <algorithm>#include <opencv2/opencv.hpp>// 多目标函数优化struct ObjectiveFunction {std::vector<double> values;void operator()(const std::vector<double>& x) const {// 这里应该根据你的具体问题来定义函数的具体形式// 这里只是一个简单的示例,只考虑了分割精度和计算效率两个目标values.resize(x.size(), 0); // 初始化所有目标值为0values[0] = 1.0; // 精度目标values[1] = 1.0; // 效率目标}};class GeneticAlgorithm {public:GeneticAlgorithm(int populationSize, int generations, double crossoverRate, double mutationRate) : populationSize(populationSize), generations(generations), crossoverRate(crossoverRate), mutationRate(mutationRate) {} std::vector<std::vector<double>> optimize(const std::vector<std::vector<double>>& inputs) {std::vector<std::vector<double>>bestSolution(inputs.size(),std::vector<double>(populationSize, 0)); // 初始化最优解double bestScore = -1; // 初始最佳分数为-1,通常需要先运行一次算法以找到初始最佳分数for (int generation = 0; generation <generations; ++generation) {std::vector<std::vector<double>>population(populationSize,std::vector<double>(populationSize, 0)); // 初始化种群for (int i = 0; i < populationSize; ++i) { std::vector<double>randomSolution(inputs.size(), 0); // 随机生成解for (int j = 0; j < inputs.size(); ++j) {randomSolution[j] = inputs[j][rand() % inputs[j].size()]; // 在输入范围内随机选择一个数作为解}population[i] = randomSolution; // 将随机解加入种群}while (!population.empty()) { // 当种群不为空时继续迭代std::sort(population.begin(), population.end(), [](const std::vector<double>& a, const std::vector<double>& b) { // 对种群进行排序,根据适应度进行排序(这里适应度是解的分数)return ObjectiveFunction()(a) > ObjectiveFunction()(b); // 如果分数更高,则适应度更好,优先选择这个解作为下一代解的一部分});std::vector<double>nextGeneration(population[0]); // 选择当前种群中的第一个解作为下一代解的一部分for (int j = 1; j < populationSize; ++j) { // 对剩余的解进行交叉和变异操作,生成下一代解if (rand() / double(RAND_MAX) < crossoverRate) { // 如果满足交叉条件,则进行交叉操作for (int k = 0; k < inputs.size(); ++k) { // 将两个解的部分基因进行交叉操作,生成新的基因序列nextGeneration[k] = population[j][k]; // 将两个解的部分基因复制到下一代解中if (rand() / double(RAND_MAX) < mutationRate) { // 如果满足变异条件,则对部分基因进行变异操作,增加种群的多样性nextGeneration[k] = nextGeneration[k] * (1 - mutationRate) + population[j][k] * mutationRate; // 对部分基因进行变异操作,增加种群的多样性}}} else { // 如果不满足交叉条件,则直接复制当前解作为下一代解的一部分for (int k = 0; k < inputs.size(); ++k) { // 将当前解的部分基因复制到下一代解中 nextGeneration[k] = population[。

遗传算法的原理及MATLAB程序实现

遗传算法的原理及MATLAB程序实现

遗传算法的原理及MATLAB程序实现1 遗传算法的原理1.1 遗传算法的基本思想遗传算法(genetic algorithms,GA)是一种基于自然选择和基因遗传学原理,借鉴了生物进化优胜劣汰的自然选择机理和生物界繁衍进化的基因重组、突变的遗传机制的全局自适应概率搜索算法。

遗传算法是从一组随机产生的初始解(种群)开始,这个种群由经过基因编码的一定数量的个体组成,每个个体实际上是染色体带有特征的实体。

染色体作为遗传物质的主要载体,其内部表现(即基因型)是某种基因组合,它决定了个体的外部表现。

因此,从一开始就需要实现从表现型到基因型的映射,即编码工作。

初始种群产生后,按照优胜劣汰的原理,逐代演化产生出越来越好的近似解。

在每一代,根据问题域中个体的适应度大小选择个体,并借助于自然遗传学的遗传算子进行组合交叉和变异,产生出代表新的解集的种群。

这个过程将导致种群像自然进化一样,后代种群比前代更加适应环境,末代种群中的最优个体经过解码,可以作为问题近似最优解。

计算开始时,将实际问题的变量进行编码形成染色体,随机产生一定数目的个体,即种群,并计算每个个体的适应度值,然后通过终止条件判断该初始解是否是最优解,若是则停止计算输出结果,若不是则通过遗传算子操作产生新的一代种群,回到计算群体中每个个体的适应度值的部分,然后转到终止条件判断。

这一过程循环执行,直到满足优化准则,最终产生问题的最优解。

图1-1给出了遗传算法的基本过程。

1.2 遗传算法的特点1.2.1 遗传算法的优点遗传算法具有十分强的鲁棒性,比起传统优化方法,遗传算法有如下优点:1. 遗传算法以控制变量的编码作为运算对象。

传统的优化算法往往直接利用控制变量的实际值的本身来进行优化运算,但遗传算法不是直接以控制变量的值,而是以控制变量的特定形式的编码为运算对象。

这种对控制变量的编码处理方式,可以模仿自然界中生物的遗传和进化等机理,也使得我们可以方便地处理各种变量和应用遗传操作算子。

遗传算法 c语言代码

遗传算法 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];}}}。

基于遗传算法PID控制寻优实现(有代码超详细)

基于遗传算法PID控制寻优实现(有代码超详细)

基于遗传优化算法对离散PID控制器参数的优化设计摘要PID控制作为一种经典的控制方法,从诞生至今,历经数十年的发展和完善,因其优越的控制性能业已成为过程控制领域最为广泛的控制方法;PID控制器具有结构简单、适应性强、不依赖于被控对象的精确模型、鲁棒性较强等优点,其控制性能直接关系到生产过程的平稳高效运行,因此对PID控制器设计和参数整定问题的研究不但具有理论价值更具有很大的实践意义,遗传算法是一种借鉴生物界自然选择和自然遗传学机理上的迭代自适应概率性搜索算法。

本论文主要应用遗传算法对PID调节器参数进行优化。

关键词:遗传优化算法PID控制器参数优化1.前言PID调节器是最早发展起来的控制策略之一,因为它所涉及的设计算法和控制结构都是简单的,并且十分适用于工程应用背景,此外PID控制方案并不要求精确的受控对象的数学模型,且采用PID控制的控制效果一般是比较令人满意的,所以在工业实际应用中,PID调节器是应用最为广泛的一种控制策略,也是历史最久、生命力最强的基本控制方式。

调查结果表明: 在当今使用的控制方式中,PID型占84. 5% ,优化PID型占68%,现代控制型占有15%,手动控制型66%,人工智能(AI)型占0.6% 。

如果把PID型和优化PID型二者加起来,则占90% 以上,这说明PID控制方式占绝大多数,如果把手动控制型再与上述两种加在一起,则占97.5% ,这说明古典控制占绝大多数。

就连科学技术高度发达的日本,PID控制的使用率也高达84.5%。

这是由于理论分析及实际运行经验已经证明了PID调节器对于相当多的工业过程能够起到较为满足的控制效果。

它结构简单、适用面广、鲁棒性强、参数易于调整、在实际中容易被理解和实现、在长期应用中己积累了丰富的经验。

特别在工业过程中,由于控制对象的精确数学模型难以建立,系统的参数又经常发生变化,运用现代控制理论分析综合要耗费很大的代价进行模型辨识,但往往不能达到预期的效果,所以不论常规调节仪表还是数字智能仪表都广泛采用这种调节方式。

基于C#运用遗传算法的排课系统

基于C#运用遗传算法的排课系统
图2课表用染色体表示的结构 Fig.2 Structu陀of schedfle《chromosomes 班级ID染色体在程序中可用十进制数编码,例如:某一 个教师编号为1234,要教“计算机基础’’这门课,课程编号为 5678,周学时为4,班级为JSJ08001、JSJ08002,随机产生上课 --86-
在实际应用中也町能没有终止条件,目的是可以依次提供不 同的可行解以供使用者选择直到所有解给完或者使用者终 止。如果只考虑最优解的问题,可以使用迭代的适应度几乎 不变作为终止条件或者规定迭代次数。值得一提的是,有些 实际问题的可行解可能是唯一的,比如教学场地或教师资源 紧缺的情况,更严重的是如果约束条件太苛刻,甚至可能没 有可行解,在此类情况下人工干预还是有必要的。
以下是排课过程中常用的软约束条件: 1)教师①老师一天之中连续上课节数;②老师课程大 部分在上午或下午;③总学分为奇数的课程一次连上三小 节;④早上8点(第一节)是否排课;⑤下午4点以后(最后 一节)是否排课;⑥中午12点(第五节)是否排课;⑦一门课 尽量分散在一个星期中。 2)学生①中午(12:00)尽量不要排课;(参上完体育课 尽量不要排课;③共同科目同班级一起上;④选修科目各班 级分开选课;⑤对于总学分为偶数的课程采取两学分课连 上;⑥对于总学分为奇数的课程采取三学分课连上;⑦学生 课表中的上课时间不能过分集中。应避免一天课程很满而另 一天却一整天没课的情况。
Electronic Design Engineering
2010年12月
Dec.2010
基于C舟运用遗传算法的排课系统
王军.陈建云 (南京信息工程大学计算机软件学院,江苏南京210044)
摘要:排课问题是典型的组合优化和不确定性调度问题,并且是NP完全问题。随着高校的发展,在教务管理系统中 使用的排课模型也变得越来越复杂,针对遗传算法排课中存在的初始解生成不合理及一周多学时课程不好安排的问

遗传算法的并行实现

遗传算法的并行实现

遗传算法的并行实现章衡 2007310437一、 问题描述遗传算法是通过模拟自然界生物进化过程来求解优化问题的一类自组织、自适应的人工智能技术。

它主要基于达尔文的自然进化论和孟德尔的遗传变异理论。

多数遗传算法的应用是处理一个由许多个体组成的群体,其中每个个体表示问题的一个潜在解。

对个体存在一个评估函数来评判其对环境的适应度。

为反映适者生存的思想,算法中设计一个选择机制,使得:适应度好的个体有更多的机会生存。

在种群的进化过程中,主要存在两种类型的遗传算子:杂交和变异。

这些算子作用于个体对应的染色体,产生新的染色体,从而构成下一代种群中的个体。

该过程不断进行,直到找到满足精度要求的解,或者达到设定的进化代数。

显然,这样的思想适合于现实世界中的一大类问题,因而具有广泛的应用价值。

遗传算法的每一次进化过程中的,各个体之间的操作大多可以并列进行,因此,一个非常自然的想法就是将遗传算法并行化,以提高计算速度。

本报告中试图得到一个并行遗传算法的框架,并考察并行化之后的一些特性。

为简单起见(本来应该考虑更复杂的问题,如TSP 。

因时间有些紧张,请老师原谅),考虑的具有问题是:对给定的正整数n 、n 元函数f ,以及定义域D ,求函数f 在D 内的最大值。

二、 串行遗传算法 1. 染色体与适应度函数对函数优化问题,一个潜在的解就是定义域D 中的一个点011(,,...,)n x x x -,因此,我们只需用一个长度为n 的实数数组来表示一个个体的染色体。

由于问题中要求求函数f 的最大值,我们可以以个体所代表点011(,,...,)n x x x -在f 函数下的值来判断该个体的好坏。

因此,我们直接用函数f 作为个体的适应度函数。

2. 选择机制选择是遗传算法中最主要的机制,也是影响遗传算法性能最主要的因素。

若选择过程中适应度好的个体生存的概率过大,会造成几个较好的可行解迅速占据种群,从而收敛于局部最优解;反之,若适应度对生存概率的影响过小,则会使算法呈现出纯粹的随机徘徊行为,算法无法收敛。

遗传算法解决TSP问题(C++)

遗传算法解决TSP问题(C++)

遗传算法解决TSP问题(C++版)遗传算法流程:交叉,编译,计算适应度,保存最优个体。

其中交叉过程是选择最优的两个染色体进行交叉操作,本文采用的是轮盘赌算法。

#include<iostream>#include<cstdlib>#include<ctime>using namespace std;#define population 200//种群数量#define pc 0.9//交叉的概率#define pm 0.1//变异的概率#define count 200//迭代的次数#define num 10//城市的数量int** city;//存放每个个体的访问顺序int path[10][10] = {//0, 1, 2, 3, 4, 5, 6, 7, 8, 9{ 0, 23, 93, 18, 40, 34, 13, 75, 50, 35 },//0{ 23, 0, 75, 4, 72, 74, 36, 57, 36, 22 },//1{ 93, 75, 0, 64, 21, 73, 51, 25, 74, 89 },//2{ 18, 4, 64, 0, 55, 52, 8, 10, 67, 1 }, //3{ 40, 72, 21, 55, 0, 43, 64, 6, 99, 74 }, //4{ 34, 74, 73, 52, 43, 0, 43, 66, 52, 39 },//5{ 13, 36, 51, 8, 64, 43, 0, 16, 57, 94 },//6{ 75, 57, 25, 10, 6, 66, 16, 0, 23, 11 }, //7{ 50, 36, 74, 67, 99, 52, 57, 23, 0, 42 },//8{ 35, 22, 89, 1, 74, 39, 94, 11, 42, 0 }//9};int* dis;//存放每个个体的访问顺序下的路径长度double* fitness;//存放灭个个体的适应度int min_dis = 1000000;int min_index = -1;int* min_path;//初始化种群void init(){int *a = new int[num];for (int i = 0; i<num; i++){a[i] = i;}city = new int*[population];for (int i = 0; i<population; i++){city[i] = new int[num];}for (int i = 0; i<population; i++){for (int j = num - 1; j >= 0; j--){int n = rand() % (j + 1);//产出的数是0-j,保证交换的后面的数不会再被交换swap(a[j], a[n]);//保证a里面全是0-(num-1)的数,无重复的数,只是顺序颠倒city[i][j] = a[j];}}delete[]a;dis = new int[population];fitness = new double[population];min_path = new int[num];}//计算适应度void compute(){//cout << "do compute now. " << endl;double total = 0;for (int i = 0; i<population; i++){//计算每种情况下,路径的长度dis[i] = 0;int a = city[i][0], b;for (int j = 1; j<num; j++){b = city[i][j];dis[i] += path[a][b];a = b;}dis[i] += path[b][city[i][0]];fitness[i] = 1.0 / dis[i];//以距离的倒数作为适应度函数值total += fitness[i];}}//选择适应度高的物种,采用轮盘赌算法int select(){double total = 0;for (int i = 0; i<population; i++){total += fitness[i];}double size = rand() / (double)RAND_MAX * total;//保证不产生0//cout << "size " << size << endl;double sum = 0;int i = 0;while (sum <= size&&i<population){sum += fitness[++i];}return --i;//返回被选中的个体}int getMinDis(){int result = dis[0];int index = 0;for (int i = 1; i<population; i++){if (result > dis[i]){result = dis[i];index = i;}}return index;}int getMaxDis(){int result = dis[0];int index = 0;for (int i = 1; i<population; i++){if (result < dis[i]){result = dis[i];index = i;}}return index;}void save(){int current_min_index = getMinDis();int current_max_index = getMaxDis();if (dis[current_min_index] < min_dis){min_dis = dis[current_min_index];for (int i = 0; i < num; i++){min_path[i] =city[current_min_index][i];}//cout << "current min dis is: " << min_dis << endl;}else{for (int i = 0; i<num; i++){city[current_max_index][i] = min_path[i];}dis[current_max_index] = min_dis;fitness[current_max_index] = 1.0 / min_dis;}}//最优保存算法bool isExist(int value, int* array, int len){for (int i = 0; i<len; i++){if (value == array[i])return true;}return false;}void convert(int p1, int p2, int* src, int* dst){int len = p2 - p1 + 1;int* temp = new int[len];for (int i = p1; i <= p2; i++){temp[i - p1] = src[i];}int j = (p2 + 1) % num;for (int i = 1; i <= num; i++){int index = (i + p2) % num;if (!isExist(dst[index], temp, len)){dst[j] = dst[index];j = (j + 1) % num;}}for (int i = p1; i <= p2; i++){dst[i] = src[i];}delete[]temp;}//交叉,采用次序交叉算法void cross(){//cout << "do cross now. " << endl;for (int k = 0; k<population; k += 2){int a = select();int b = select();while (a == b){b = select();//保证被选中的个体不是一样的//cout << "same " << b << endl;}//cout << "choose popuilation" << a << " " << b << endl;double p = rand() / double(RAND_MAX);//cout << "cross rate is " << p << endl;int* a1 = new int[num];int* a2 = new int[num];int* b1 = new int[num];int* b2 = new int[num];for (int i = 0; i<num; i++){a1[i] = city[a][i];a2[i] = city[b][i];b1[i] = a2[i];b2[i] = a1[i];}if (p<pc)//满足交叉条件{//选择交叉的两点,并保证p1<p2int p1 = -1;int p2 = -1;while (p1 == p2){p1 = rand() % num;p2 = rand() % num;if (p1>p2){swap(p1, p2);}}//cout << "choose pos " << p1 << " " << p2 << endl;//开始交叉convert(p1, p2, a1, b1);convert(p1, p2, a2, b2);for (int i = 0; i<num; i++){city[k][i] = b1[i];city[k + 1][i] = b2[i];}}else{for (int i = 0; i<num; i++){city[k][i] = a1[i];city[k + 1][i] = a2[i];}}delete[]a1;delete[]a2;delete[]b1;delete[]b2;}}//变异,采用对换操作进行变异void morphis(){//cout << "do morphis now. " << endl;for (int i = 0; i<population; i++){double p = rand() / double(RAND_MAX);//cout << "morphis rate is " << p << endl;if (p<pm)//执行变异{int a = -1, b = -1;while (a == b){a = rand() % num;b = rand() % num;}swap(city[i][a], city[i][b]);}}}int getdis(){//compute();int result = dis[0];int index = 0;for (int i = 1; i<population; i++){if (result > dis[i]){result = dis[i];index = i;}}return result;}//释放申请的数组的空间void dispose(){for (int i = 0; i<population; i++){delete[]city[i];}delete[]city;delete[]dis;delete[]fitness;}int main(){init();//初始化种群int i = 0;srand(time(0));compute();while (i<count){cross();//交叉morphis();//变异compute();//计算适应度save();//保存当前最优的个体//cout << "count " << i++ << endl;cout << getdis() << " ";//输出结果//cout << min_index << " ";if (++i % 10 == 0)cout << endl;}compute();cout << "min distance is: " << min_dis << endl;for (int i = 0; i<num; i++)cout << min_path[i] << " ";cout << endl;dispose();//释放空间return 0;}。

遗传算法C语言代码

遗传算法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 *//**************************************** ************************///搜寻杰出个体函数:找出最好和最坏的个体。

GA-遗传算法-C#代码

GA-遗传算法-C#代码

using System;using System.IO;using System.Collections;using System。

Collections.Generic;using System.Text;using System。

ComponentModel;using System.Data;using System。

Data。

OleDb;namespace ConsoleApplication1{public class Genetic_Algorithm{Random rand=new Random();int MaxTime;//最大运行时间int popsize;//种群数量int ChromosomeLength;//染色体长度double CrossRate;//交叉率double MutateRate;//变异率double[] f;//适应度值int[] selected;//定义selected数组,用于表示需要进行交叉操作的染色体序号double[] wheel;//轮盘int[,] pregeneration;//上一代int[,] nextgeneration;//下一代int[] Best;//定义当前最优解int convergence;//定义当前最优解的已持续代数int[,] timeconstrait;public Genetic_Algorithm(int populationsize,int chromolength)//GA——构造函数,变量初始化{rand = new Random(System。

DateTime。

lisecond);MaxTime = 50;popsize=populationsize;ChromosomeLength = chromolength;CrossRate = 0.8;MutateRate = 0.2;f = new double[2*popsize];selected = new int[popsize];wheel = new double[popsize + 1];pregeneration = new int[popsize, ChromosomeLength];//当前的染色体种群nextgeneration = new int[popsize, ChromosomeLength];//下一代(子代)染色体种群Best = new int[ChromosomeLength];convergence = 1;timeconstrait = new int[20, 2] { { 2, 6 }, { 1, 2 },{ 3, 4 }, { 1, 4 }, { 4, 7 }, { 3, 5 }, { 2, 6 }, { 3, 5 }, { 1, 4 }, { 3, 7 }, { 5, 7 }, { 2, 7 }, { 2, 4 }, { 4, 5 }, { 2, 5 },{ 4, 6 }, { 3, 5 }, { 1, 4 },{ 1, 5 },{ 3, 6 } };}public void RunGA()//运行{int i;CreateFirstPop();//产生初始种群i = 0;bool quit = true;while (quit){for (; i 〈 MaxTime; i++){Console.WriteLine("The {0}th Generation。

遗传算法简单易懂的例子

遗传算法简单易懂的例子

遗传算法简单实例为更好地理解遗传算法的运算过程,下面用手工计算来简单地模拟遗传算法的各个主要执行步骤。

例:求下述二元函数的最大值:(1) 个体编码遗传算法的运算对象是表示个体的符号串,所以必须把变量x1, x2 编码为一种符号串。

本题中,用无符号二进制整数来表示。

因 x1, x2 为 0 ~ 7之间的整数,所以分别用3位无符号二进制整数来表示,将它们连接在一起所组成的6位无符号二进制数就形成了个体的基因型,表示一个可行解。

例如,基因型 X=101110 所对应的表现型是:x=[ 5,6 ]。

个体的表现型x和基因型X之间可通过编码和解码程序相互转换。

(2) 初始群体的产生遗传算法是对群体进行的进化操作,需要给其淮备一些表示起始搜索点的初始群体数据。

本例中,群体规模的大小取为4,即群体由4个个体组成,每个个体可通过随机方法产生。

如:011101,101011,011100,111001(3) 适应度汁算遗传算法中以个体适应度的大小来评定各个个体的优劣程度,从而决定其遗传机会的大小。

本例中,目标函数总取非负值,并且是以求函数最大值为优化目标,故可直接利用目标函数值作为个体的适应度。

(4) 选择运算选择运算(或称为复制运算)把当前群体中适应度较高的个体按某种规则或模型遗传到下一代群体中。

一般要求适应度较高的个体将有更多的机会遗传到下一代群体中。

本例中,我们采用与适应度成正比的概率来确定各个个体复制到下一代群体中的数量。

其具体操作过程是:•先计算出群体中所有个体的适应度的总和fi ( i=1.2,…,M );•其次计算出每个个体的相对适应度的大小 fi / fi ,它即为每个个体被遗传到下一代群体中的概率,•每个概率值组成一个区域,全部概率值之和为1;•最后再产生一个0到1之间的随机数,依据该随机数出现在上述哪一个概率区域内来确定各个个体被选中的次数。

(5) 交叉运算交叉运算是遗传算法中产生新个体的主要操作过程,它以某一概率相互交换某两个个体之间的部分染色体。

遗传算法简介及代码详解

遗传算法简介及代码详解

遗传算法简述及代码详解声明:本文内容整理自网络,认为原作者同意转载,如有冒犯请联系我。

遗传算法基本内容遗传算法为群体优化算法也就是从多个初始解开始进行优化每个解称为一个染色体,各染色体之间通过竞争、合作、单独变异,不断进化。

染色体:又可以叫做基因型个体(individuals)群体/种群(population):一定数量的个体组成,及一定数量的染色体组成,群体中个体的数量叫做群体大小。

初始群体:若干染色体的集合,即解的规模,如30,50等,认为是随机选取的数据集合。

适应度(fitness):各个个体对环境的适应程度优化时先要将实际问题转换到遗传空间就是把实际问题的解用染色体表示称为编码,反过程为解码/译码,因为优化后要进行评价(此时得到的解是否较之前解优越),所以要返回问题空间,故要进行解码。

SGA采用二进制编码,染色体就是二进制位串,每一位可称-可编辑修改-为一个基因;如果直接生成二进制初始种群,则不必有编码过程,但要求解码时将染色体解码到问题可行域内。

遗传雌的准备工作:1)数据转换操作,包括表现型到基因型的转换和基因型到表现型的转换。

前者是把求解空间中的参数转化成遗传空间中的染色体或者个体(encoding),后者是它的逆操作(decoding)2)确定适应度计算函数,可以将个体值经过该函数转换为该个体的适应度,该适应度的高低要能充分反映该个体对于解得优秀程度。

非常重要的过程。

遗传算法基本过程为:1)编码,创建初始群体2)群体中个体适应度计算3)评估适应度4)根据适应度选择个体5)被选择个体进行交叉繁殖6)在繁殖的过程中引入变异机制7)繁殖出新的群体,回到第二步实例一:(建议先看实例二)求X金1,30]范围内的y = Q -10%的最小值-可编辑修改-1)编码算法选择为"将X转化为2进制的串",串的长度为5位(串的长度根据解的精度设定,串长度越长解得精度越高)(等位基因的值为0 or 1)。

遗传算法的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 ()初始化种群和遗传算法参数。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

一需求分析1.本程序演示的是用简单遗传算法随机一个种群,然后根据所给的交叉率,变异率,世代数计算最大适应度所在的代数2.演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”之后,由用户在键盘上输入演示程序中规定的命令;相应的输入数据和运算结果显示在其后。

3.测试数据输入初始变量后用y=100*(x1*x1-x2)*(x1*x2-x2)+(1-x1)*(1-x1)其中-2.048<=x1,x2<=2.048作适应度函数求最大适应度即为函数的最大值二概要设计1.程序流程图2.类型定义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();4.程序的各函数的简单算法说明如下:(1).void generateinitialpopulation ()和void input ()初始化种群和遗传算法参数。

input() 函数输入种群大小,染色体长度,最大世代数,交叉率,变异率等参数。

(2)void calculateobjectvalue();计算适应度函数值。

根据给定的变量用适应度函数计算然后返回适度值。

(3)选择函数selectoperator()在函数selectoperator()中首先用rand ()函数产生0~1间的选择算子,当适度累计值不为零时,比较各个体所占总的适应度百分比的累计和与选择算子,直到达到选择算子的值那个个体就被选出,即适应度为fi的个体以fi/∑fk的概率继续存在;显然,个体适应度愈高,被选中的概率愈大。

但是,适应度小的个体也有可能被选中,以便增加下一代群体的多样性。

(4)染色体交叉函数crossoveroperator()这是遗传算法中的最重要的函数之一,它是对个体两个变量所合成的染色体进行交叉,而不是变量染色体的交叉,这要搞清楚。

首先用rand ()函数产生随机概率,若小于交叉概率,则进行染色体交叉,同时交叉次数加1。

这时又要用rand()函数随机产生一位交叉位,把染色体的交叉位的后面部分交叉即可;若大于交叉概率,则进行简单的染色体复制即可。

(5)染色体变异函数mutation()变异是针对染色体字符变异的,而不是对个体而言,即个体变异的概率是一样。

随机产生比较概率,若小于变异概率,则1变为0,0变为1,同时变异次数加1。

(6)long decodechromosome(char *,int,int)本函数是染色体解码函数,它将以数组形式存储的二进制数转成十进制数,然后才能用适应度函数计算。

(7)void findbestandworstindividual()本函数是求最大适应度个体的,每一代的所有个体都要和初始的最佳比较,如果大于就赋给最佳。

(8)void outputtextreport () 输出种群统计结果输出每一代的种群的最大适应度和平均适应度,最后输出全局最大值三运行环境本程序的开发工具是VC++,在VC++下运行。

四源代码#include <stdio.h>#include<stdlib.h>#include<time.h>#include<math.h>#define POPSIZE 500#define maximization 1#define minimization 2#define cmax 100#define cmin 0#define length1 10#define length2 10#define chromlength length1+length2 //染色体长度int functionmode=maximization;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];//函数声明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();void generateinitialpopulation( ) //种群初始化{int i,j;for (i=0;i<popsize; i++){for(j=0;j<chromlength;j++){population[i].chrom[j]=(rand()%10<5)?'0':'1';}population[i].chrom[chromlength]='\0';}}void generatenextpopulation() //生成下一代{selectoperator();crossoveroperator();mutationoperator();}void evaluatepopulation() //评价个体,求最佳个体{calculateobjectvalue();calculatefitnessvalue();findbestandworstindividual();}long decodechromosome(char *string ,int point,int length) //给染色体解码{int i;long decimal=0;char*pointer;for(i=0,pointer=string+point;i<length;i++,pointer++)if(*pointer-'0'){decimal +=(long)pow(2,i);}return (decimal);}void calculateobjectvalue() //计算函数值{int i;long temp1,temp2;double x1,x2;for (i=0; i<popsize; i++){temp1=decodechromosome(population[i].chrom,0,length1);temp2=decodechromosome(population[i].chrom,length1,length2);x1=4.096*temp1/1023.0-2.048;x2=4.096*temp2/1023.0-2.048;population[i].value=100*(x1*x1-x2)* (x1*x1-x2)+(1-x1)*(1-x1);}}void calculatefitnessvalue()//计算适应度{int i;double temp;for(i=0;i<popsize;i++){if(functionmode==maximization){if((population[i].value+cmin)>0.0){temp=cmin+population[i].value;}else{temp=0.0;}}else if (functionmode==minimization){if(population[i].value<cmax){temp=cmax-population[i].value;}else{ temp=0.0;}}population[i].fitness=temp;}}void findbestandworstindividual( ) //求最佳个体和最差个体{int i;double sum=0.0;bestindividual=population[0];worstindividual=population[0];for (i=1;i<popsize; i++){if (population[i].fitness>bestindividual.fitness){bestindividual=population[i];best_index=i;}else if (population[i].fitness<worstindividual.fitness) {worstindividual=population[i];worst_index=i;}sum+=population[i].fitness;}if (generation==0){currentbest=bestindividual;}else{if(bestindividual.fitness>=currentbest.fitness){currentbest=bestindividual;}}}void performevolution() //演示评价结果{if (bestindividual.fitness>currentbest.fitness){currentbest=population[best_index];}else{population[worst_index]=currentbest;}}void selectoperator() //比例选择算法{int i,index;double p,sum=0.0;double cfitness[POPSIZE];struct individual newpopulation[POPSIZE];for(i=0;i<popsize;i++){sum+=population[i].fitness;}for(i=0;i<popsize; i++){cfitness[i]=population[i].fitness/sum;}for(i=1;i<popsize; i++){cfitness[i]=cfitness[i-1]+cfitness[i];}for (i=0;i<popsize;i++){p=rand()%1000/1000.0;index=0;while (p>cfitness[index]){index++;}newpopulation[i]=population[index];}for(i=0;i<popsize; i++){population[i]=newpopulation[i];}}void crossoveroperator() //交叉算法{int i,j;int index[POPSIZE];int point,temp;double p;char ch;for (i=0;i<popsize;i++){index[i]=i;}for (i=0;i<popsize;i++){point=rand()%(popsize-i);temp=index[i];index[i]=index[point+i];index[point+i]=temp;}for (i=0;i<popsize-1;i+=2){p=rand()%1000/1000.0;if (p<pc){point=rand()%(chromlength-1)+1;for (j=point; j<chromlength;j++){ch=population[index[i]].chrom[j];population[index[i]].chrom[j]=population[index[i+1]].chrom[j];population[index[i+1]].chrom[j]=ch;}}}}void mutationoperator() //变异操作{int i,j;double p;for (i=0;i<popsize;i++){for(j=0;j<chromlength;j++){p=rand()%1000/1000.0;if (p<pm){population[i].chrom[j]=(population[i].chrom[j]=='0')?'1':'0';}}}}void input() //数据输入{ printf("初始化全局变量:\n");printf(" 种群大小(50-500):");scanf("%d", &popsize);if((popsize%2) != 0){printf( " 种群大小已设置为偶数\n");popsize++;};printf(" 最大世代数(100-300):");scanf("%d", &maxgeneration);printf(" 交叉率(0.2-0.99):");scanf("%f", &pc);printf(" 变异率(0.001-0.1):");scanf("%f", &pm);}void outputtextreport()//数据输出{int i;double sum;double average;sum=0.0;for(i=0;i<popsize;i++){sum+=population[i].value;}average=sum/popsize;printf("当前世代=%d\n当前世代平均函数值=%f\n当前世代最高函数值=%f\n",generation,average,population[best_index].value);}void main() //主函数{ int i;printf("本程序为求函数y=100*(x1*x1-x2)*(x1*x2-x2)+(1-x1)*(1-x1)的最大值\n其中-2.048<=x1,x2<=2.048\n");generation=0;input();generateinitialpopulation();evaluatepopulation();while(generation<maxgeneration){generation++;generatenextpopulation();evaluatepopulation();performevolution();outputtextreport();}printf("\n");printf(" 统计结果: ");printf("\n");printf("最大函数值等于:%f\n",currentbest.fitness);printf("其染色体编码为:");for (i=0;i<chromlength;i++){printf("%c",currentbest.chrom[i]);}printf("\n"); }六测试结果。

相关文档
最新文档