ROSENBROCK函数代码.docx
《ROSENBROCK函数代码.docx》由会员分享，可在线阅读，更多相关《ROSENBROCK函数代码.docx（12页珍藏版）》请在冰豆网上搜索。
ROSENBROCK函数代码
首先申明，这个程序不是我写的，也是我以前在网上找到的（本科的时候看过，没太看懂，但是测试过了，可以运行的）。
这是完整的rosenbrock函数的代码，绝对可用：
function[f,df,ddf]=rosenbrock（x）;
%rosenbrock.mThisfunctionreturnsthefunctionvalue,partialderivatives
%andHessianofthe（generaldimension）rosenbrockfunction,givenby:
%
%f（x）=sum_{i=1:
D-1}100*（x（i+1）-x（i）^2）^2+（1-x（i））^2
%
%whereDisthedimensionofx.Thetrueminimumis0atx=（11...1）.
%
%CarlEdwardRasmussen,2001-07-21.
D=length（x）;
f=sum（100*（x（2:
D）-x（1:
D-1）.^2）.^2+（1-x（1:
D-1））.^2）;
ifnargout>1
df=zeros（D,1）;
df（1:
D-1）=-400*x（1:
D-1）.*（x（2:
D）-x（1:
D-1）.^2）-2*（1-x（1:
D-1））;
df（2:
D）=df（2:
D）+200*（x（2:
D）-x（1:
D-1）.^2）;
end
ifnargout>2
ddf=zeros（D,D）;
ddf（1:
D-1,1:
D-1）=diag（-400*x（2:
D）+1200*x（1:
D-1）.^2+2）;
ddf（2:
D,2:
D）=ddf（2:
D,2:
D）+200*eye（D-1）;
ddf=ddf-diag（400*x（1:
D-1）,1）-diag（400*x（1:
D-1）,-1）;
end
比如说，你可以使用常用的多目标函数的优化来调用：
>>[xfxc]=minimize（[01]','rosenbrock',50）
Linesearch1;Value9.801010e-001
Linesearch2;Value7.711174e-001
Linesearch3;Value6.087456e-001
Linesearch4;Value4.170023e-001
Linesearch5;Value3.019709e-001
Linesearch6;Value2.622712e-001
Linesearch7;Value5.074002e-002
Linesearch8;Value4.360344e-002
Linesearch9;Value2.569778e-002
Linesearch10;Value9.313900e-003
Linesearch11;Value2.831055e-003
Linesearch12;Value6.570921e-004
Linesearch13;Value7.260670e-005
Linesearch14;Value2.660941e-007
Linesearch15;Value3.306084e-011
Linesearch16;Value1.640334e-012
Linesearch17;Value4.746897e-014
Linesearch18;Value6.733194e-020
Linesearch19;Value2.144528e-025
Linesearch20;Value1.343529e-030
Linesearch21;Value4.930381e-032
x=
1.0000
1.0000
fx=
101.0000
0.9801
0.7711
0.6087
0.4170
0.3020
0.2623
0.0507
0.0436
0.0257
0.0093
0.0028
0.0007
0.0001
0.0000
0.0000
0.0000
0.0000
0.0000
0.0000
0.0000
0.0000
c=
23
>>
minimize时多目标优化的函数，你应该不需要的。
用遗传算法求解Rosenbrock函数源代码
2008-05-0219:
49:
10|分类：
程序算法|标签：
|字号大中小订阅
/*
基本遗传算法实例程序
求解Rosenbrock函数
Version1.0
ProgrammedbyJimZhou,1994.12.
*/
#include
#include
#include
/*
常量定义
*/
#definePOPSIZE500//群体大小
#defineMAXIMIZATION1//最大标志，寻找最大解
#defineMINIMIZATION2//最小标志，寻找最小解
/*
数据定义
（对于不同的问题，可能会有少许差别）
*/
#defineCmax100//确定的最大值
#defineCmin0//确定的最小值
#defineLENGTH110//第一个染色体长度
#defineLENGTH210//第二个染色体长度
#defineCHROMLENGTHLENGTH1+LENGTH2//染色体总长度
intFunctionMode=MAXIMIZATION;//求解最优值类型：
最大？
最小
intPopSize=80;//群体规模M
intMaxGeneration=200;//最大代数
doublePc=0.6;//交叉概率
doublePm=0.001;//变异概率
/*
数据结构定义
*/
structindividual//个体数据结构
{
charchrom[CHROMLENGTH+1];//个体的基因型，用字符串表示
doublevalue;//个体的目标值
doublefitness;//个体的适应度
};
/*
全局变量定义
*/
intgeneration;//代数
intbest_index;//最优个体的索引
intworst_index;//最坏个体的索引
structindividualbestindividual;//当代最优个体
structindividualworstindividual;//当代最坏个体
structindividualcurrentbest;//迄今为止，最好的个体
structindividualpopulation[POPSIZE];//群体
/*
函数原型声明
*/
voidGenerateInitialPopulation（void）;
voidGenerateNextPopulation（void）;
voidEvaluatePopulation（void）;
longDecodeChromosome（char*,int,int）;
voidCalculateFitnessValue（void）;
voidCalculateObjectValue（void）;
voidFindBestAndWorstIndividual（void）;
voidPerformEvolution（void）;
voidSelectionOperator（void）;
voidCrossoverOperator（void）;
voidMutationOperator（void）;
voidOutputTextReport（void）;
/*
主程序
*/
voidmain（void）
{
generation=0;
GenerateInitialPopulation（）;
EvaluatePopulation（）;
while（generation{
generation++;
GenerateNextPopulation（）;
EvaluatePopulation（）;
PerformEvolution（）;
OutputTextReport（）;
}
}
/*
函数：
产生第一代个体
参数：
void
*/
voidGenerateInitialPopulation（void）
{
inti,j;
srand（time（NULL））;
for（i=0;i{
for（j=0;j{
population[i].chrom[j]=（rand（）%10<5）?
'0':
'1';
}
population[i].chrom[CHROMLENGTH]=0;
}
}
/*
函数：
初始化第一代个体
参数：
void
*/
voidGenerateNextPopulation（void）
{
SelectionOperator（）;
CrossoverOperator（）;
MutationOperator（）;
}
/*
函数：
通过特定的方程式评估群体
参数：
void
*/
voidEvaluatePopulation（void）
{
CalculateObjectValue（）;
CalculateFitnessValue（）;
FindBestAndWorstIndividual（）;
}
/*
函数：
将染色体的基因型解码成表现型
参数：
void
备注：
返回值可能是正、或负。
对于不同的解码方法，这个值也可能是“unsignedint”
*/
longDecodeChromosome（char*string,intpoint,intlength）
{
inti;
longdecimal=0L;
char*pointer;
for（i=0,pointer=string+point;i{
decimal+=（*pointer-'0'）<<（length-1-i）;
}
returndecimal;
}
/*
函数：
计算目标值
参数：
void
备注：
对于不同的问题，用户需要修改此处代码。
该代码实例是求解Rosenbrock函数
Rosenbrock函数定义如下：
f（x1,x2）=100*（x1**2-x2）**2+（1-x1）**2
该函数的最大值是：
f（-2.048,-2.048）=3905.926227
*/
voidCalculateObjectValue（void）
{
inti;
longtemp1,temp2;
doublex1,x2;
for（i=0;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
*/
voidCalculateFitnessValue（void）
{
inti;
doubletemp;
for（i=0;i{
if（FunctionMode==MAXIMIZATION）
{
if（（population[i].value+Cmin）>0.0）
{
temp=Cmin+population[i].value;
}
else
{
temp=0.0;
}
}
elseif（FunctionMode==MINIMIZATION）
{
if（population[i].value{
temp=Cmax-population[i].value;
}
else
{
temp=0.0;
}
}
population[i].fitness=temp;
}
}
/*
函数：
查找至今的最优个体
参数：
void
*/
voidFindBestAndWorstIndividual（void）
{
inti;
doublesum=0.0;
bestindividual=population[0];
worstindividual=population[0];
for（i=1;i{
if（population[i].fitness>bestindividual.fitness）
{
bestindividual=population[i];
best_index=i;
}
elseif（population[i].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
*/
voidPerformEvolution（void）
{
if（bestindividual.fitness>currentbest.fitness）
{
currentbest=population[best_index];
}
else
{
population[worst_index]=currentbest;
}
}
/*
函数：
用选择操作重新选择一个染色体
参数：
void
*/
voidSelectionOperator（void）
{
inti,index;
doublep,sum=0.0;
doublecfitness[POPSIZE];
structindividualnewpopulation[POPSIZE];
for（i=0;i{
sum+=population[i].fitness;
}
for（i=0;i{
cfitness[i]=population[i].fitness/sum;
}
for（i=1;i{
cfitness[i]=cfitness[i-1]+cfitness[i];
}
for（i=0;i{
p=rand（）%1000/1000.0;
index=0;
while（p>cfitness[index]）
{
index++;
}
newpopulation[i]=population[index];
}
for（i=0;i{
population[i]=newpopulation[i];
}
}
/*
函数：
采用单点交叉方式对染色体进行交叉操作
参数：
void
*/
voidCrossoverOperator（void）
{
inti,j;
intindex[POPSIZE];
intpoint,temp;
doublep;
charch;
for（i=0;i{
index[i]=i;
}
srand（time（NULL））;
for（i=0;i{
point=rand（）%（PopSize-i）;
temp=index[i];
index[i]=index[point+i];
index[point+i]=temp;
}
for（i=0;i{
p=rand（）%1000/1000.0;
if（p{
point=rand（）%（CHROMLENGTH-1）+1;
for（j=point;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
*/
voidMutationOperator（void）
{
inti,j;
doublep;
srand（time（NULL））;
for（i=0;i{
for（j=0;j{
p=rand（）%1000/1000.0;
if（p{
population[i].chrom[j]=（population[i].chrom[j]=='0'）?
'1':
'0';
}
}
}
}
/*
函数：
输出当代的结果
参数：
void
*/
voidOutputTextReport（void）
{
inti;
doublesum;
doubleaverage;
sum=0.0;
for（i=0;i{
sum+=population[i].value;
}
average=sum/PopSize;
printf（"gen=%2d,avg=%f,best=%f,",generation,average,currentbest.value）;
printf（"chromosome="）;
for（i=0;i{
printf（"%c",currentbest.chrom[i]）;
}
printf（"\n"）;
}
升级会员 