最优化方法课程实验报告.docx

最优化方法课程实验报告.docx

《最优化方法课程实验报告.docx》由会员分享，可在线阅读，更多相关《最优化方法课程实验报告.docx（57页珍藏版）》请在冰豆网上搜索。

最优化方法课程实验报告

资料范本

本资料为word版本，可以直接编辑和打印，感谢您的下载

最优化方法课程实验报告

地点：

__________________

时间：

__________________

说明：

本资料适用于约定双方经过谈判，协商而共同承认，共同遵守的责任与义务，仅供参考，文档可直接下载或修改，不需要的部分可直接删除，使用时请详细阅读内容

项目一一维搜索算法

（一）

[实验目的]

编写加步探索法、对分法、Newton法的程序。

[实验准备]

1．掌握一维收搜索中搜索区间的加步探索法的思想及迭代步骤；

2．掌握对分法的思想及迭代步骤；

3．掌握Newton法的思想及迭代步骤。

[实验内容及步骤]

编程解决以下问题：

1．用加步探索法确定一维最优化问题

的搜索区间，要求选取．

加步探索法算法的计算步骤：

（1）选取初始点，计算．给出初始步长，加步系数，令。

（2）比较目标函数值．令，计算，若，转（3），否则转（4）。

（3）加大探索步长．令，同时，令，转

（2）。

（4）反向探索．若，转换探索方向，令，转

（2）。

否则，停止迭代，令。

加步探索法算法的计算框图

程序清单

加步探索法算法程序见附录1

实验结果

运行结果为：

2．用对分法求解

，

已知初始单谷区间，要求按精度，分别计算．

对分法迭代的计算步骤：

（1）确定初始搜索区间，要求。

（2）计算的中点．

（3）若，则，转（4）；若，则，转（5）；若，则，转（4）．

（4）若，则，转（5）；否则转

（2）．

（5）打印，结束

对分法的计算框图

程序清单

对分法程序见附录2

实验结果

运行结果为：

3．用Newton法求解

，

已知初始单谷区间，要求精度．

Newton法的计算步骤

（1）确定初始搜索区间，要求

（2）选定

（3）计算

（4）若，则，转（3）；否则转（5）．

（5）打印，结束．

Newton法的计算框图

程序清单

Newton法程序见附录3

实验结果

运行结果为：

项目二一维搜索算法

（二）

[实验目的]

编写黄金分割法、抛物线插值法的程序。

[实验准备]

1．掌握黄金分割法的思想及迭代步骤；

2．掌握抛物线插值法的思想及迭代步骤。

[实验内容及步骤]

编程解决以下问题：

1．用黄金分割法求解

，

已知初始单谷区间，要求精度．

黄金分割法迭代步骤：

（1）确定的初始搜索区间．

（2）计算

（3）计算

（4）若，则打印，结束；否则转（5）．

（5）判别是否满足：

若满足，则置

然后转（3）；否则，置

然后转（4）．

黄金分割法的计算框图：

程序清单

黄金分割法程序见附录4

实验结果

运行结果为：

2．用抛物线插值法求解

，

已知初始单谷区间．

抛物线插值法的计算步骤：

，所以相对来说是好点，故划掉区间，保留为新区间，故置，，保持不变；

，所以相对来说是好点，故划掉区间，保留为新区间，故置，与保持不变；

程序清单

抛物线插值法程序见附录5

实验结果

运行结果为：

项目三常用无约束最优化方法

（一）

[实验目的]

编写最速下降法、Newton法（修正Newton法）的程序。

[实验准备]

1．掌握最速下降法的思想及迭代步骤。

2．掌握Newton法的思想及迭代步骤；

3．掌握修正Newton法的思想及迭代步骤。

[实验内容及步骤]

编程解决以下问题：

1．用最速下降法求

．

最速下降法计算步骤

（1）

（2）

（3）

（4）

最速下降法的计算框图

程序清单

最速下降法程序见附录6

实验结果

运行结果为：

2．用Newton法求

，

初始点．

Newton法的计算步骤

（1）给定初始点，及精度，令；

（2）若，停止，极小点为，否则转步骤（3）；

（3）计算，令；

令，，转步骤

（2）。

程序清单

Newton法程序见附录7

实验结果

运行结果为：

3．用修正Newton求

，

初始点．

修正Newton的计算步骤

（1）给定初始点，及精度，令；

（2）若，停止，极小点为，否则转步骤（3）；

（3）计算，令；

（4）用一维搜索法求，使得，令，，转步骤

（2）。

程序清单

修正Newton程序见附录8

实验结果

运行结果为：

项目四常用无约束最优化方法

（二）

实验目的

编写共轭梯度法、变尺度法（DFP法和BFGS法）程序。

实验准备

1．掌握共轭方向法的思路及迭代过程；

2．掌握共轭梯度法的思想及迭代步骤；

3．掌握DFP法和BFGS法的思想及迭代步骤。

实验内容及步骤

编程解决以下问题：

用共轭梯度法求得，取初始点，．

共轭梯度法算法步骤

给定初始点，及精度；

若，停止，极小值点为，否则转步骤（3）；

取，且置；

用一维搜索法求，使得，令，，转步骤5；

若，停止，极小值点为，否则转步骤（6）；

若，令，转步骤（3），否则转步骤（7）；

令，，置，转步骤（4）。

程序清单

共轭梯度法程序见附录9

实验结果

运行结果为：

用共轭梯度法求，自定初始点，．

程序清单

共轭梯度法程序见附录9

实验结果

运行结果为：

3．用DFP法求，初始点．

DFP法的具体迭代步骤如下：

（1）给定初始点，迭代精度，维数n

（2）置0→k，单位矩阵I→，计算。

（3）计算搜索方向

（4）进行一维搜索求，使

得迭代新点

（5）检验是否满足迭代终止条件‖‖≤？

若满足，停止迭代，输出最优解,；否则进行下一步。

（6）检查迭代次数，若k=n，则置，转向步骤

（2）；若k

（7）计算：

。

然后，置k+1→k，转向步骤（3）。

DFP法的计算框图

程序清单

DFP法程序见附录10

实验结果

运行结果为：

项目五常用约束最优化方法

[实验目的]

编写外点罚函数法、外点罚函数法的程序。

[实验准备]

1．掌握外点罚函数法的思想及迭代步骤；

2．掌握内点罚函数法的思想及迭代步骤。

[实验内容及步骤]

编程解决以下问题：

1．用外点罚函数法编程计算

精度．

外点法的计算步骤：

（1）给定初始点x（0），初始罚因子，

放大系数c>1；允许误差e>0,设置k=1；

（2）以x（k-1）作为搜索初始点，求解无约束规划问题

，令x（k）为所求极小点。

（3）当，则停止计算，得到点x（k）；否则，令，返回

（2）执行。

程序清单

外点罚函数法程序见附录11

实验结果

实验结果为

运行结果为：

2．用内点罚函数法编程计算

初始点取为，初始障碍因子取，缩小系数取．

内点罚步骤：

给定初始内点，允许误差e>0，

障碍参数，缩小系数，置k=1；

以为初始点，求解下列规划问题：

，令为所求极小点

如果，则停止计算，得到结果，

否则令，置k=k+1，返回

（2）。

内点罚计算框图

程序清单

内点罚函数法程序见附录12

实验结果

运行结果为：

附录1

#include

#include

#defineMAX20480

doublefun（doublex）

{

returnx*x*x-2*x+1;

}

doubleMax_Num（doublea,doubleb）

{

if（a>b）

returna;

else

returnb;

}

doubleMin_Num（doublea,doubleb）{

if（a

returna;

else

returnb;

}

voidStepAdding_Search（double&a,double&b）

{

doublet[MAX]={0};

doubleh[MAX]={0};

doublef[MAX]={0};

doubleresult=0;

doublep=2;

t[0]=0;

h[0]=1;

f[0]=fun（t[0]）;

for（intk=0;k

{

t[k+1]=t[k]+h[k];

f[k+1]=fun（t[k+1]）;

if（f[k+1]

{

h[k+1]=p*h[k];

result=t[k];

t[k]=t[k+1];

f[k]=f[k+1];

}

elseif（k==0）

{

h[k]=-h[k];

result=t[k+1];

}

else{

a=Min_Num（result,t[k+1]）;

b=Max_Num（result,t[k+1]）;

}

}

}

intmain（）

{

doublea=0.0;

doubleb=0.0;

StepAdding_Search（a,b）;

cout<<"该问题的根的搜索空间是:

["<

return0;

}

附录2

#include

#include

#defineeps0.001

doublefun（doublex）

{

returnx*x+2*x;

}

doublediff_fun（doublex）

{

return2*x+2;

}

doubledichotomy（doublea,doubleb）

{

doublec=0.0;

if（（diff_fun（a）<0）&&（diff_fun（b）>0））

{

while（true）

{

c=（a+b）/2;

if（diff_fun（c）<0）

{

a=c;

if（fabs（（a-b））

{

return（a+b）/2;

}

}

elseif（diff_fun（c）==0）

{

returnc;

}

else

{

b=c;

if（fabs（（a-b））

{

return（a+b）/2;

}}}}}

intmain（）

{

doublea=-3.0;

doubleb=5.0;

doubleresult=dichotomy（a,b）;

cout<<"求解的结果是:

"<

return0;

}

附录3

#include

#include

#defineeps0.01

doublefun（doublex）

{

returnx*x*x-2*x+1;

}

doublediff_fun（doublex）

{

return3*x*x-2;

}

doublediff_2_fun（doublex）

{

return6*x;

}

doublenewton（doublea,doubleb）

{

doubleresult=（a+b）/2;

doublet=0.0;

while（true）

{

t=result-（diff_fun（result）/diff_2_fun（result））;

if（fabs（（t-result））

{

returnresult;

}

else

{

result=t;

}

}

}

intmain（）

{

doublea=0.0;

doubleb=3.0;

doublex=newton（a,b）;

cout<<"求解的结果是x="<

cout<<"此时f（x）="<

return0;

}

附录4

#include

#include

usingnamespacestd;

doublefun（doublet）

{

return（t*t+2*t）;

}

voidGoldensection（double（*pfun）（doublet））

{

intmaxflag=1000,k=1;

doublea=-3,b=5,err=0.001,t,t1,t2;

do

{

t1=a+0.618*（b-a）;

t2=b-0.618*（b-a）;

if（t1=t2）{a=t2;b=t1;}

else{if（t1

else{b=t1;}}

k++;

}while（fabs（a-b）>err&&k

if（k>=maxflag）

cout<

迭代次数为k="<

{

t=（a+b）/2;

cout<

迭代次数为k="<

cout<<"迭代结果：

近似根为root="<

f（root）="<

}

intmain（）

{

Goldensection（fun）;

return0;

}

附录5

#include

#include

usingnamespacestd;

doublefun（doublex）

{

return（8*x*x*x-2*x*x-7*x+3）;

}

doublemax（doublea,doubleb）

{

if（a>b）returna;

elsereturnb;

}

doublemin（doublea,doubleb）

{

if（a>b）returnb;

elsereturna;

}

voidParainterpolation（double（*pfun）（doublex））{

doublea=0,b=2,err=0.001,x=0,x0=1,f,f0;

do

{

x=（（x0*x0-b*b）*fun（a）+（b*b-a*a）*fun（x0）+（a*a-x0*x0）*fun（b））/（2*（（x0-b）*fun（a）+（b-a）*fun（x0）+（a-x0）*fun（b）））;

f0=fun（x0）;

f=fun（x）;

if（f=f0）{a=min（x,x0）;b=max（x,x0）;x0=（a+b）/2;}

else{

if（（fun（x）-f0）*（x-x0）>0）

{

b=max（x,x0）;x0=min（x,x0）;

}

else

{

a=min（x,x0）;x0=max（x,x0）;

}

}

}while（fabs（x-x0）>err）;

x=（x+x0）/2;

cout<<"迭代结果：

"<

cout<<"近似根:

"<

cout<<"函数值近似为:

"<

}

intmain（）

{

Parainterpolation（fun）;

return0;

}

附录6

#include

#include

doublelamda（doublex[2],doublep[2],doublea[2]）{

doublelam1,lam2;

lam1=（pow（a[0],3）*x[0]*x[0]+pow（a[1],3）*x[1]*x[1]）;

lam2=-（pow（a[0]*x[0],2）+pow（a[1]*x[1],2））;

doubles;

s=-lam2/（2*lam1）;

returns;

}

voidmain（）

{

cout<<"最速下降法求解最优解程序运行结果"<

cout<

doublelamd,x[3],a[6];

doublep[2],g[2],e,y,m,n;inti=0;

cout<<"请输入精度e"<>e;

cout<<"请输入初始点x[0],x[1]的值：

\n"<

cin>>m;

cin>>n;

x[0]=m;x[1]=n;

cout<<"函数通式为f（x）=a[0]x1*x1+a[1]x2*x2+a[2]x1*x2+a[3]x1+a[4]x2+a[5]"<

cout<<"请依次输入函数的系数：

a[0]、a[1]、a[2]、a[3]、a[4]、a[5]:

"<

for（i=0;i<6;i++）

cin>>a[i];

p[0]=（2*a[0]*x[0]+a[2]*x[1]+a[3]）;

p[1]=（2*a[1]*x[1]+a[2]*x[0]+a[4]）;

g[0]=-p[0];g[1]=-p[1];i=0;cout<

while（sqrt（g[0]*g[0]+g[1]*g[1]）>e&&i<=200）{

lamd=lamda（x,g,a）;

x[0]=x[0]+lamd*g[0];

x[1]=x[1]+lamd*g[1];

p[0]=2*a[0]*x[0];

p[1]=2*a[1]*x[1];

g[0]=-p[0];

g[1]=-p[1];

i++;

cout<<"******************************************"<

cout<<"第"<

"<

cout<<"p的模为：

"<

cout<<"x的值"<

cout<<"******************************************"<

cout<

}

y=（a[0]*x[0]*x[0]+a[1]*x[0]*x[1]+a[2]*x[0]*x[1]+a[3]*x[0]+a[4]*x[1]+a[5]）;

cout<<"此时满足精度要求的p的模为:

"<

cout<

cout<<"满足精度的最优近似结果x[1],x[2]分别为：

"<

cout<<"x[1]="<

cout<<"x[2]="<

cout<<"满足进度要求所得的最优值为：

"<

cout<<"minf（x）="<

}

附录7

#include

#include"matrix.h"//矩阵的有关运算

intconstn1=2;

doublef（double*x）;//目标函数;

voidg（double*x,double*y）;//目标函数的梯度;

voidmain（）

{

inti;

doublex0[n1],x1[n1],g0[n1],g1[n1],H[n1][n1],h[n1][n1],p[n1],f0,f1,temp,e;

x0[0]=0;x0[1]=0;e=0.01;H[0][0]=2;H[0][1]=-1;H[1][0]=-1;H[1][1]=2;

f0=f（x0）;

g（x0,g0）;

matrix_inv（H,h）;

matrix_mul（h,g0,p）;

//matrix_minus（x0,p,x1）;

for（i=0;i

x1[i]=x0[i]-p[i];

g（x1,g1）;

f1=f（x1）;

temp=g1[0]*g1[0]+g1[1]*g1[1];

while（temp>e）

{

for（i=0;i

{

x0[i]=x1[i];

g0[i]=g1[i];

}

f0=f1;

matrix_mul（h,g0,p）;

for（i=0;i

x1[i]=x0[i]-p[i];

g（x1,g1）;

f1=f（x1）;

temp=g1[0]*g1[0]+g1[1]*g1[1];

}

cout<<"当X取X（"<

}

doublef（double*x）

{

return60-10*x[0]-4*x[1]+x[0]*x[0]+x[1]*x[1]-x[0]*x[1];

}

voidg（double*x,double*y）

{

y[0]=2*x[0]-x[1]-10;

y[1]=2*x[1]-x[0]-4;

}

附录8

#include

#include

#include

#definen2//正定二次函数的自变量个数

doublefun（doublex[n],doublef_xs[n+n+1+（n-1）*n/2]）//输入变量为函数自变量初值

{

inti,j;

doublef=0;

for（i=0;i

{

f+=pow（x[i],2）*f_xs[i];

}

for（;i<2*n;i++）//计算X部分

{

f+=x[i%n]*f_xs[i];

}

f+=f_xs[i];//计算常数项部分

for（i=0;i

{

for（j=i+1;j

{

f+=f_xs[（n+1）+n*（i+1）-i*（i+1）/2+j-i-1]*x[i]*x[j];

}

}

returnf;

}

voidQ_fun（doublef_xs[n+n+1+（n-1）*n/2],doubleQ[n][n+1]）

{

inti,j;

for（i=0;i

{

Q[i][i]=2*f_xs[i];

}

for（i=0;i

{

Q[i][n]=f_xs[n+i];

}

for（i=0;i

{

for（j=i+1;j

{

Q[j][i]=Q[i][j]=f_xs[（n+1）+n*（i+1）-i*（i+1）/2+j-i-1];

}

}

}

voidD_fun（doublex[n],doubleQ[n][n+1],doubleg0[n]）//自变量初值，正定二次函数的各项系数，返回梯度的初值

{

inti,j;

for（i=0;i

{

g0[i]=0;//清零

for（j=0;j

{

if（i==j）

g0[i]+=Q[i][j]*x[j];

else

g0[i]+=Q[i][j]*x[j];

}

}

for（i=0;i

{

g0[i]+=Q[i][n];

}

cout<

for（i=0;i

cout<

co