完整word版机械优化设计实验报告word文档良心出品.docx

完整word版机械优化设计实验报告word文档良心出品.docx

《完整word版机械优化设计实验报告word文档良心出品.docx》由会员分享，可在线阅读，更多相关《完整word版机械优化设计实验报告word文档良心出品.docx（38页珍藏版）》请在冰豆网上搜索。

完整word版机械优化设计实验报告word文档良心出品

《机械优化设计》

实验报告

1.进退法确定初始区间

1.1进退法基本思路：

按照一定的规则试算若干个点，比较其函数值的大小，直至找到函数值按“高-低-高”变化的单峰区间。

1.2进退法程序框图

1.3题目：

用进退法求解函数

的搜索区间

1.4源程序代码及运行结果

#include

#include

main（）

{

floath,h0,y1,y2,y3,a1=0,a2,a3,fa2,fa3;

scanf（"h0=%f,y1=%f",&h0,&y1）;

h=h0;a2=h;y2=a2*a2-7*a2+10;

if（y2>y1）

{

h=-h;a3=a1;y3=y1;

loop:

a1=a2;y1=y2;a2=a3;y2=y3;

}

a3=a2+2*h;y3=a3*a3-7*a3+10;

if（y3

{

gotoloop;

}

else

printf（"a1=%f,a2=%f,a3=%f,y1=%f,y2=%f,y3=%f\n",a1,a2,a3,y1,y2,y3）;

}

搜索区间为06

2.黄金分割法

2.1黄金分割法基本思路：

通过不断的缩短单峰区间的长度来搜索极小点的一种有效方法。

按

（

）缩小比较

大小确定取舍区间。

2.2黄金分割法流程图

2.3题目：

对函数

，给定搜索区间

时，试用黄金分割法求极小点

2.4源程序代码及结果：

f=inline（'x^2-7*x+9'）

a=0;b=8;eps=0.001;

a1=b-0.618*（b-a）;y1=f（a1）;

a2=a+0.618*（b-a）;y2=f（a2）;

while（abs（b-a）>eps）

if（y1>=y2）

a=a1;

a1=a2;

y1=y2;

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

y2=f（a2）;

else

b=a2;a2=a1;y2=y1;

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

y1=f（a1）;

end

end

xxx=0.5*（a+b）

f=

Inlinefunction:

f（x）=x^2-7*x+9

xxx=

3.4997

3.牛顿型法

3.1牛顿型法基本思路：

在

邻域内用一个二次函数

来近似代替原目标函数，并将

的极小点作为对目标函数

求优的下一个迭代点

。

经多次迭代，使之逼近目标函数

的极小点。

3.2阻尼牛顿法的流程图：

3.3题目：

用牛顿阻尼法求函数

的极小点

3.4源程序代码及结果：

k=0;

ptol=1.0e-5;

xk=input（'inputx0:

'）

itcl=[1;1];

whilenorm（itcl）>=ptol

f1=[4*xk（1,1）^3-24*xk（1,1）^2+50*xk（1,1）-4*xk（2,1）-32;-4*xk（1,1）+8*xk（2,1）];

G=[12*xk（1,1）^2-48*xk（1,1）+50,-4;-4,8];

dk=-inv（G）*f1;a=-（dk'*f1）/（dk'*G*dk）;

xk=xk+a*dk;

itcl=a*dk;

k=k+1;

end

f=（xk（1,1）-2）^4+（xk（1,1）-2*xk（2,1））^2;

fprintf（'\nÓÃ×èÄáÅ£¶Ù·¨µü´ú%d´ÎºóµÃµ½¼«Ð¡µãx*¼°¼«Ð¡ÖµfΪ:

\n',k）;

disp（xk）;

disp（f）;

结果显示：

inputx0:

[1;1]

用阻尼牛顿法迭代27次后得到极小点x*及极小值f为:

2.0000

1.0000

1.3270e-019

4.鲍威尔法

4.1鲍威尔法基本思路：

在不用导数的前提下，在迭代中逐次构造G的共轭方向。

4.2鲍威尔法流程图：

4．3题目：

求函数f（x）=x[0]*x[0]+x[1]*x[1]-x[0]*x[1]-10*x[0]-4*x[1]+60的最优点，收敛精度ε=0.001

4.4源程序代码及结果：

#include"stdio.h"

#include"stdlib.h"

#include"math.h"

doubleobjf（doublex[]）

{doubleff;

ff=x[0]*x[0]+x[1]*x[1]-x[0]*x[1]-10*x[0]-4*x[1]+60;

return（ff）;

}

voidjtf（doublex0[],doubleh0,doubles[],intn,doublea[],doubleb[]）

{inti;

double*x[3],h,f1,f2,f3;

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

x[i]=（double*）malloc（n*sizeof（double））;

h=h0;

for（i=0;i

*（x[0]+i）=x0[i];

f1=objf（x[0]）;

for（i=0;i

*（x[1]+i）=*（x[0]+i）+h*s[i];

f2=objf（x[1]）;

if（f2>=f1）

{h=-h0;

for（i=0;i

*（x[2]+i）=*（x[0]+i）;

f3=f1;

for（i=0;i

{*（x[0]+i）=*（x[1]+i）;

*（x[1]+i）=*（x[2]+i）;

}

f1=f2;

f2=f3;

}

for（;;）

{h=2*h;

for（i=0;i

*（x[2]+i）=*（x[1]+i）+h*s[i];

f3=objf（x[2]）;

if（f2

else

{for（i=0;i

{*（x[0]+i）=*（x[1]+i）;

*（x[1]+i）=*（x[2]+i）;

}

f1=f2;

f2=f3;

}

}

if（h<0）

for（i=0;i

{a[i]=*（x[2]+i）;

b[i]=*（x[0]+i）;

}

else

for（i=0;i

{a[i]=*（x[0]+i）;

b[i]=*（x[2]+i）;

}

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

free（x[i]）;

}

doublegold（doublea[],doubleb[],doubleeps,intn,doublexx[]）

{inti;

doublef1,f2,*x[2],ff,q,w;

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

x[i]=（double*）malloc（n*sizeof（double））;

for（i=0;i

{*（x[0]+i）=a[i]+0.618*（b[i]-a[i]）;

*（x[1]+i）=a[i]+0.382*（b[i]-a[i]）;

}

f1=objf（x[0]）;

f2=objf（x[1]）;

do

{if（f1>f2）

{for（i=0;i

{b[i]=*（x[0]+i）;

*（x[0]+i）=*（x[1]+i）;

}

f1=f2;

for（i=0;i

*（x[1]+i）=a[i]+0.382*（b[i]-a[i]）;

f2=objf（x[1]）;

}

else

{for（i=0;i

{a[i]=*（x[1]+i）;

*（x[1]+i）=*（x[0]+i）;}

f2=f1;

for（i=0;i

*（x[0]+i）=a[i]+0.618*（b[i]-a[i]）;

f1=objf（x[0]）;

}

q=0;

for（i=0;i

q=q+（b[i]-a[i]）*（b[i]-a[i]）;

w=sqrt（q）;

}while（w>eps）;

for（i=0;i

xx[i]=0.5*（a[i]+b[i]）;

ff=objf（xx）;

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

free（x[i]）;

return（ff）;

}

doubleoneoptim（doublex0[],doubles[],doubleh0,doubleepsg,intn,doublex[]）

{double*a,*b,ff;

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

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

jtf（x0,h0,s,n,a,b）;

ff=gold（a,b,epsg,n,x）;

free（a）;

free（b）;

return（ff）;

}

doublepowell（doublep[],doubleh0,doubleeps,doubleepsg,intn,doublex[]）

{inti,j,m;

double*xx[4],*ss,*s;

doublef,f0,f1,f2,f3,fx,dlt,df,sdx,q,d;

ss=（double*）malloc（n*（n+1）*sizeof（double））;

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

for（i=0;i

{for（j=0;j<=n;j++）

*（ss+i*（n+1）+j）=0;

*（ss+i*（n+1）+i）=1;

}

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

xx[i]=（double*）malloc（n*sizeof（double））;

for（i=0;i

*（xx[0]+i）=p[i];

for（;;）

{for（i=0;i

{*（xx[1]+i）=*（xx[0]+i）;

x[i]=*（xx[1]+i）;

}

f0=f1=objf（x）;

dlt=-1;

for（j=0;j

{for（i=0;i

{*（xx[0]+i）=x[i];

*（s+i）=*（ss+i*（n+1）+j）;

}

f=oneoptim（xx[0],s,h0,epsg,n,x）;

df=f0-f;

if（df>dlt）

{dlt=df;

m=j;

}

}

sdx=0;

for（i=0;i

sdx=sdx+fabs（x[i]-（*（xx[1]+i）））;

if（sdx

{free（ss）;

free（s）;

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

free（xx[i]）;

return（f）;

}

for（i=0;i

*（xx[2]+i）=x[i];

f2=f;

for（i=0;i

{*（xx[3]+i）=2*（*（xx[2]+i）-（*（xx[1]+i）））;

x[i]=*（xx[3]+i）;

}

fx=objf（x）;

f3=fx;

q=（f1-2*f2+f3）*（f1-f2-dlt）*（f1-f2-dlt）;

d=0.5*dlt*（f1-f3）*（f1-f3）;

if（（f3

{if（f2<=f3）

for（i=0;i

*（xx[0]+i）=*（xx[2]+i）;

else

for（i=0;i

*（xx[0]+i）=*（xx[3]+i）;

}

else

{for（i=0;i

{*（ss+（i+1）*（n+1））=x[i]-（*（xx[1]+i））;

*（s+i）=*（ss+（i+1）*（n+1））;

}

f=oneoptim（xx[0],s,h0,epsg,n,x）;

for（i=0;i

*（xx[0]+i）=x[i];

for（j=m+1;j<=n;j++）

for（i=0;i

*（ss+i*（n+1）+j-1）=*（ss+i*（n+1）+j）;

}

}

}

voidmain（）

{doublep[]={1,2};

doubleff,x[2];

ff=powell（p,0.3,0.001,0.0001,2,x）;

printf（"x[0]=%f,x[1]=%f,ff=%f\n",x[0],x[1],ff）;

getchar（）;

}

5.复合形法

5.1复合行法基本思想：

在可行域中选取K个设计点（n+1≤K≤2n）作为初始复合形的顶点。

比较各顶点目标函数值的大小，去掉目标函数值最大的顶点（称最坏点），以坏点以外其余各点的中心为映射中心，用坏点的映射点替换该点，构成新的复合形顶点。

反复迭代计算，使复合形不断向最优点移动和收缩，直至收缩到复合形的顶点与形心非常接近，且满足迭代精度要求为止。

5.2题目：

求函数f（x）=（x1-5）*（x1-5）+4*（x2-6）*（x2-6）的最优点，约束条件为g1（x）=64-x1*x1-x2*x2≤0；g2（x）=x2-x1-10≤0；g3（x）=x1-10≤0；收敛精度ε自定义；

5.3源程序代码及结果：

#include

#include

#include

#include

#defineE01e-5/*复合形法收敛控制精度*/

double**apply（int,int）;/*申请矩阵空间*/

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

double*g（double*）;/*约束函数*/

booljudge（double*）;/*可行点的判断*/

intmain（）

{intn,k;

inti,j,k1;

intl;

doubletemporary;

doublerestrain;/*收敛条件*/

doublereflect;/*反射系数*/

srand（（unsigned）time（NULL））;

printf（"请输入目标函数的维数n:

"）;/*输入已知数据*/

scanf（"%d",&n）;

printf（"请输入复合形的顶点数k:

"）;

scanf（"%d",&k）;

double**x=apply（k,n）;/*存放复合形顶点*/

double*y=（double*）calloc（k,sizeof（double））;/*存放目标函数值*/

double*p=（double*）calloc（3,sizeof（double））;/*存放约束函数值*/

double*a=（double*）calloc（n,sizeof（double））;/*存放设计变量的下限*/

double*b=（double*）calloc（n,sizeof（double））;/*存放设计变量的上限*/

double*x_c=（double*）calloc（n,sizeof（double））;/*存放可行点中心*/

double*x_r=（double*）calloc（n,sizeof（double））;/*存放最坏点的反射点*/

printf（"请输入选定的第一个可行点x1（包含%d个数）:

",n）;

for（i=0;i

scanf（"%lf",*x+i）;

printf（"请输入初选变量的下限a（包含%d个数）:

",n）;

for（i=0;i

printf（"请输入初选变量的上限b（包含%d个数）:

",n）;

for（i=0;i

printf（"输出输入结果为:

\nn=%d,k=%d,x1=（",n,k）;/*输出已知数据*/

for（i=0;i

printf（"%.5lf",*（*x+i））;

printf（"%.5lf）\na=（",*（*x+n-1））;

for（i=0;i

printf（"%f",*（a+i））;

printf（"%.5lf）,b=（",*（a+n-1））;

for（i=0;i

printf（"%f",*（b+i））;

printf（"%.5lf）\n",*（b+n-1））;

L1:

for（i=1;i

for（j=0;j

*（*（x+i）+j）=*（a+j）+（double）（rand（）%10000）/10000*（*（b+j）-*（a+j））;

l=1;

for（i=1;i

if（judge（*（x+i）））

{

for（j=1;j

if（!

judge（*（x+j）））

{

for（k1=0;k1

{

temporary=*（*（x+i）+k1）;

*（*（x+i）+k1）=*（*（x+j）+k1）;

*（*（x+j）+k1）=temporary;

}

break;

}

l++;

}

for（i=0;i

for（j=i+1;j

if（f（*（x+i））

for（k1=0;k1

{

temporary=*（*（x+i）+k1）;

*（*（x+i）+k1）=*（*（x+j）+k1）;

*（*（x+j）+k1）=temporary;

}

for（i=0;i

*（x_c+i）=0;

for（i=0;i

for（j=0;j

*（x_c+j）+=*（*（x+i）+j）;

for（i=0;i

*（x_c+i）/=l;

if（!

judge（x_c））/*判断可行点中心是否可行*/

{

for（i=0;i

{

*（a+i）=*（*（x+l-1）+i）;

*（b+i）=*（x_c+i）;

}

gotoL1;

}

else

{

for（i=l;i

do

{

for（j=0;j

*（*（x+i）+j）=*（x_c+j）+0.5*（*（*（x+i）+j）-*（x_c+j））;

}

while

（!

judge（*（x+i）））;

L2:

for（i=0;i

for（j=i+1;j

if（f（*（x+i））

for（k1=0;k1

{

temporary=*（*（x+i）+k1）;

*（*（x+i）+k1）=*（*（x+j）+k1）;

*（*（x+j）+k1）=temporary;

}

restrain=0;/*求收敛条件*/

for（i=0;i

restrain+=（f（*（x+i））-f（*（x+k-1）））*（f（*（x+i））-f（*（x+k-1）））;

restrain=sqrt（1.0/（k-1）*restrain）;

if（restrain

{

printf（"\n求得约束最优点为:

（"）;

for（i=0;i

printf（"%.5f",*（*（x+k-1）+i））;

printf（"）\n目标函数的最优解为:

%.5f\n",f（*（x+k-1）））;

return0;

}

else

{

L3:

for（i=0;i

*（x_c+i）=0;

for（i=1;i

for（j=0;j

*（x_c+j）+=*（*（x+i）+j）;

for（i=0;i

*（x_c+i）/=k-1;

reflect=1.3;

L4:

for（i=0;i

*（x_r+i）=*（x_c+i）+reflect*（*（x_c+i）-*（*x+i））;

if（!

judge（x_r））

{

reflect*=0.5;

gotoL4;

}

elseif

（f（x_r）

{

for（i=0;i

gotoL2;