优化设计实验报告1.docx

优化设计实验报告1.docx

《优化设计实验报告1.docx》由会员分享，可在线阅读，更多相关《优化设计实验报告1.docx（20页珍藏版）》请在冰点文库上搜索。

优化设计实验报告1

机械优化设计

实

验

报

告

姓名：

***

学号：

**********

班级：

07机设一班

一、黄金分割法

1、数学模型

，

2、黄金分割法简介

黄金分割法适用于单谷函数求极小值问题，且函数可以不连续。

黄金分割法是建立在区间消去法原理基础上的试探方法，即在搜索区间

内适当插入两点

、

，并计算其函数值。

、

将区间分成三段。

应用函数的单谷性质，通过函数值大小的比较，删去其中一段，使搜索区间得以缩短。

然后再在保留下来的区间上作同样的处置，如此迭代下去，使搜索区间无限缩小，从而得到极小点的数值近似解。

黄金分割法能使相邻两次都具有相同的缩短率0.618，故黄金分割法又称作0.618法。

3、黄金分割法程序清单

#include

#include

/*目标函数*/

floatff（floatx）

{

floaty;

y=x*x+2*x;

return（y）;

}

main（）

{

floata,b,ab,Epsilon;

floaty1,y2,Alpha1,Alpha2;

floatLambda=0.618;

printf（"pleaseinputthearearandEpsilon\n"）;

scanf（"%f,%f,%f",&a,&b,&Epsilon）;

Alpha1=b-Lambda*（b-a）,Alpha2=a+Lambda*（b-a）;

printf（"%f,%f\n",Alpha1,Alpha2）;

y1=ff（Alpha1）;y2=ff（Alpha2）;

printf（"y1=%f,y2=%f\n",y1,y2）;

do

{if（y1>=y2）

{a=Alpha1;

Alpha1=Alpha2;

y1=y2;

Alpha2=a+Lambda*（b-a）;

y2=Alpha2*Alpha2+2*Alpha2;

}

else{

b=Alpha2;

Alpha2=Alpha1;

y2=y1;

Alpha1=b-Lambda*（b-a）;

y1=Alpha1*Alpha1+2*Alpha1;

}

printf（"a=%f,b=%f,y1=%f,y2=%f\n",a,b,y1,y2）;

}while（!

（abs（（b-a）/b）

ab=0.5*（a+b）;

y1=ff（ab）;

printf（"theresultis：

%f",y1）;

getch（）;

}

4、运行结果：

一、变尺度法

1、数学模型

2、变尺度法简介

基本思想：

（1）用简单矩阵代替二阶导数矩阵的逆矩阵

（2）用坐标变换简化目标函数

具体如下：

当用牛顿法寻求极小点时，其牛顿迭代公式为

其中

在迭代中建立变尺度矩阵

来替换

，即构造一个矩阵序列

来逼近海赛逆矩阵序列

。

每迭代一次，尺度就改变一次，这正是“变尺度”的含义。

这样，上式变为

其中

是从

出发，沿方向

作一维搜索而得到

的最佳步长。

当

（单位矩阵）时，它就变成最速下降法。

这就是变尺度法的基本思想。

变尺度法程序清单：

/*计算f（x1,x2）=x1^2+8*x2^2-4*x1-2*x1*x2的无约束极值，初始点x0=[1,1]。

tt----一维搜索初始步长

ff----差分法求梯度时的步长

ac----终止迭代收敛精度

ad----一维搜索收敛精度

n-----设计变量的维数

xk[n]--迭代初始点

*/

#include

#include

#include

#include

#definett0.01

#defineff1.0e-6

#defineac1.0e-6

#definead1.0e-6

#definen8

doubleia;

doublefny（double*x）

{

doublex1=x[0],x2=x[1];

doublef;

f=x1*x1+8*x2*x2-4*x1-2*x1*x2;

returnf;

}

double*iterate（double*x,doublea,double*s）

{

double*x1;

inti;

x1=（double*）malloc（n*sizeof（double））;

for（i=0;i

x1[i]=x[i]+a*s[i];

returnx1;

}

doublefunc（double*x,doublea,double*s）

{

double*x1;

doublef;

x1=iterate（x,a,s）;

f=fny（x1）;

returnf;

}

voidfinding（doublea[3],doublef[3],double*xk,double*s）

{

doublet=tt;

inti;

doublea1,f1;

a[0]=0;f[0]=func（xk,a[0],s）;

for（i=0;;i++）

{

a[1]=a[0]+t;

f[1]=func（xk,a[1],s）;

if（f[1]

if（fabs（f[1]-f[0]）>=ad）

{

t=-t;

a[0]=a[1];f[0]=f[1];

}

else

{

if（ia==1）return;

t=t/2;ia=1;

}

}

for（i=0;;i++）

{

a[2]=a[1]+t;

f[2]=func（xk,a[2],s）;

if（f[2]>f[1]）break;

t=2*t;

a[0]=a[1];f[0]=f[1];

a[1]=a[2];f[1]=f[2];

}

if（a[0]>a[2]）

{

a1=a[0];

f1=f[0];

a[0]=a[2];

f[0]=f[2];

a[2]=a1;

f[2]=f1;

}

return;

}

doublelagrange（double*xk,double*ft,double*s）

{

inti;

doublea[3],f[3];

doubleb,c,d,aa;

finding（a,f,xk,s）;

for（i=0;;i++）

{

if（ia==1）{aa=a[1];*ft=f[1];break;}

d=（pow（a[0],2）-pow（a[2],2））*（a[0]-a[1]）-（pow（a[0],2）-pow（a[1],2））*（a[0]-a[2]）;

if（fabs（d）==0）break;

c=（（f[0]-f[2]）*（a[0]-a[1]）-（f[0]-f[1]）*（a[0]-a[2]））/d;

if（fabs（c）==0）break;

b=（（f[0]-f[1]）-c*（pow（a[0],2）-pow（a[1],2）））/（a[0]-a[1]）;

aa=-b/（2*c）;

*ft=func（xk,aa,s）;

if（fabs（aa-a[1]）<=ad）{if（*ft>f[1]）aa=a[1];break;}

if（aa>a[1]）

{

if（*ft>f[1]）{a[2]=aa;f[2]=*ft;}

elseif（*ft

elseif（*ft==f[1]）

{

a[2]=aa;a[0]=a[1];

f[2]=*ft;f[0]=f[1];

a[1]=（a[0]+a[2]）/2;

f[1]=func（xk,a[1],s）;

}

}

else

{

if（*ft>f[1]）{a[0]=aa;f[0]=*ft;}

elseif（*ft

elseif（*ft==f[1]）

{a[0]=aa;a[2]=a[1];

f[0]=*ft;f[2]=f[1];

a[1]=（a[0]+a[2]）/2;

f[1]=func（xk,a[1],s）;

}

}

}

if（*ft>f[1]）{*ft=f[1];aa=a[1];}

returnaa;

}

double*gradient（double*xk）

{

double*g,f1,f2,q;

inti;

g=（double*）malloc（n*sizeof（double））;

f1=fny（xk）;

for（i=0;i

{q=ff;

xk[i]=xk[i]+q;f2=fny（xk）;

g[i]=（f2-f1）/q;xk[i]=xk[i]-q;

}

returng;

}

double*bfgs（double*xk）

{

doubleu[n],v[n],h[n][n],dx[n],dg[n],s[n];

doubleaa,ib;

double*ft,*xk1,*g1,*g2,*xx,*x0=xk;

doublefi;

inti,j,k;

ft=（double*）malloc（sizeof（double））;

xk1=（double*）malloc（n*sizeof（double））;

for（i=0;i

{

s[i]=0;

for（j=0;j

{

h[i][j]=0;

if（j==i）h[i][j]=1;

}

}

g1=gradient（xk）;

fi=fny（xk）;

x0=xk;

for（k=0;k

{

ib=0;

if（ia==1）{xx=xk;break;}

ib=0;

for（i=0;i

for（i=0;i

for（j=0;j

s[i]+=-h[i][j]*g1[j];

aa=lagrange（xk,ft,s）;

xk1=iterate（xk,aa,s）;

g2=gradient（xk1）;

for（i=0;i

if（（fabs（g2[i]）>=ac）&&（fabs（g2[i]-g1[i]）>=ac））

{ib=ib+1;}

if（ib==0）{xx=xk1;break;}

fi=*ft;

if（k==n-1）

{intj;

xk=xk1;

for（i=0;i

for（j=0;j

{

h[i][j]=0;

if（j==i）h[i][j]=1;

}

g1=g2;k=-1;

}

else

{

intj;

doublea1=0,a2=0;

for（i=0;i

{

dg[i]=g2[i]-g1[i];

dx[i]=xk1[i]-xk[i];

}

for（i=0;i

{

intj;

u[i]=0;v[i]=0;

for（j=0;j

{

u[i]=u[i]+dg[j]*h[j][i];

v[i]=v[i]+dg[j]*h[i][j];

}

}

for（j=0;j

{

a1+=dx[j]*dg[j];

a2+=v[j]*dg[j];

}

if（fabs（a1）!

=0）

{

a2=1+a2/a1;

for（i=0;i

for（j=0;j

h[i][j]+=（a2*dx[i]*dx[j]-v[i]*dx[j]-dx[i]*u[j]）/a1;

}

xk=xk1;g1=g2;

}

}

if（*ft>fi）{*ft=fi;xx=xk;}

xk=x0;

returnxx;

}

voidmain（）

{

intk;

double*xx,f;

doublexk[n]={1,1};

xx=bfgs（xk）;

f=fny（xx）;

printf（"\n\nTheOptimalDesignResultIs:

\n"）;

for（k=0;k

{printf（"\nk=%d\n\tx[%d]*=%f",k,k+1,xx[k]）;}

printf（"\n\tf*=%f",f）;

getch（）;

}

4、运行结果：

三、复合形法

1、数学模型

2、复合形法简介

复合形法是指n维空间上取k（

）个点作为顶点所构成的n维超多面体。

（1）基本思路：

在可行域内选取若干初始点，并以之为顶点构成一个多面体（复合形），然后比较个顶点的函数值，去掉最坏点，代之以好的新点，并构成新的复合形，以逼近最优点。

（2）初始复合形的生成

法一：

由设计者根据问题性质，自行确定K个可行点来生成复合形

法二：

设计者选择一个可行点，其它由随机函数来生成（K-1）个

式中：

是随机函数生的随机数。

法三：

全部由计算机自动生成初始复合形的全部顶点。

（3）复合形法的搜索方法

一、反射二、扩张三、收缩四、压缩

3、复合形法程序清单：

/*已知：

F（x1,x2）=8*x1-x2的平方-16；求极小值，极小值点，迭代次数？

用复合形法求极值。

约束条件：

x2>=0;

x1>=0;

25-x1的平方-x2的平方>=0;*/

#include

#include

#defineEP0.0001

#defineE0.001

#defineforifor（i=0;i<=1;i++）

inti;

floatf（float*p）

{

floaty;

y=8*p[0]-pow（p[1],2）-16;

return（y）;

}

intcons（float*q）

{

intn;

if（（pow（q[0],2）+pow（q[1],2）-25<=0）&&（q[0]>=0）&&（q[1]>=0））

n=1;

else

n=0;

return（n）;

}

voidpaixu（float*p1,float*p2,float*p3）

{

floatf1,f2,f3;

floatL[2],M[2],H[2];

f1=f（p1）;

f2=f（p2）;

f3=f（p3）;

fori{H[i]=p1[i];M[i]=p2[i];L[i]=p3[i];}

if（f1>f2）

{

if（f2

if（f1>f3）

fori{M[i]=p3[i];L[i]=p2[i];}

else

fori{H[i]=p3[i];M[i]=p1[i];L[i]=p2[i];}

}

else

if（f2

fori{H[i]=p3[i];L[i]=p1[i];}

else

if（f1>f3）

fori{H[i]=p2[i];M[i]=p1[i];L[i]=p3[i];}

else

fori{H[i]=p2[i];M[i]=p3[i];L[i]=p1[i];}

fori{p1[i]=H[i];p2[i]=M[i];p3[i]=L[i];}

}

floatr（）

{

floatrr;

do

rr=rand（）;

while（rr<=0）;

rr=rr/32767;

return（rr）;

}

main（）

{

floatx1[2]={2,1},x2[2]={4,1},x3[2]={3,3};

floatXC[2],XR[2],A[2],B[2];

floatH=1.3,FH,FR,FC,FL,cha,min,S;

inttf,tf1,tf2,j=1;

do

{

do

{

paixu（x1,x2,x3）;

/*

foriprintf（"\nX1%dis%f,X2%dis%f,X3%dis%f.",i,x1[i],i,x2[i],i,x3[i]）;

*/

foriXC[i]=（x2[i]+x3[i]）/2;

/*

foriprintf（"\nXC%dis%f.",i,XC[i]）;

*/

tf1=cons（XC）;

if（tf1==0）

{

FC=f（XC）;

FL=f（x3）;

if（FL

fori{A[i]=x3[i];B[i]=XC[i];}

else

fori{A[i]=XC[i];B[i]=x3[i];}

do

{S=r（）;x1[i]=A[i]+S*（B[i]-A[i]）;tf2=cons（x1）;}

while（tf2==0）;

do

{S=r（）;x2[i]=A[i]+S*（B[i]-A[i]）;tf2=cons（x2）;}

while（tf2==0）;

do

{S=r（）;x3[i]=A[i]+S*（B[i]-A[i]）;tf2=cons（x3）;}

while（tf2==0）;

}

}

while（tf1==0）;

foriXR[i]=XC[i]+H*（XC[i]-x1[i]）;

/*

foriprintf（"\nXR%dis%f.",i,XR[i]）;

*/

FH=f（x1）;

FR=f（XR）;

tf=cons（XR）;

if（tf&&（FR

{

forix1[i]=XR[i];

/*

printf（"\n1"）;

*/

}

else

H=H/2;

/*

printf（"\nHis%f.",H）;

*/

if（H

fori{x1[i]=x2[i];H=1.3;}

cha=（pow（（f（x1）-f（x3））,2）+pow（（f（x2）-f（x3））,2））/2;

/*

printf（"/nChais%f.",cha）;

*/

printf（"i=%d\tFH=%f\tFR=%f\tFC=%f\tFL=%f\n",j++,FH,FR,FC,FL）;/**/

}

while（cha>E）;

min=f（x3）;

printf（"\nTheMinis%f.",min）;

foriprintf（"\nTheX%dis%f.",i,x3[i]）;

getch（）;

4、运行结果：