机械优化设计实验报告docx.docx

机械优化设计实验报告docx.docx

《机械优化设计实验报告docx.docx》由会员分享，可在线阅读，更多相关《机械优化设计实验报告docx.docx（33页珍藏版）》请在冰豆网上搜索。

机械优化设计实验报告docx

《机械优化设计》

实验报告

1.进退法确定初始区间3

1.1进退法基本思路3

1.2进退法程序框图3

1.3题目4

1.4源程序代码及运行结果4

2.黄金分割法5

2.2黄金分割法流程图5

2.3题目5

2.4源程序代码及结果5

3.牛顿型法6

3.1牛顿型法基本思路6

3.2阻尼牛顿法的流程图6

3.3题目7

3.4源程序代码及结果7

4.鲍威尔法8

4.1鲍威尔法基本思路8

4.2鲍威尔法流程图8

4．3题目9

4.4源程序代码及结果9

5.复合形法16

5.1复合行法基本思想16

5.3源程序代码及结果16

6.外点惩罚函数法24

6.1解题思路：

24

6.2流程框图24

6.3题目24

6.4源程序代码及结果24

7.机械设计实际问题分析30

7.2计算过程如下30

7.3源程序编写32

8.报告总结33

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.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′?

oóμ?

μ?

?

?

D?

μ?

x*?

°?

?

D?

?

μf?

a:

\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<