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

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

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

复合形法.................................................................

16

5.1

复合行法基本思想....................................................

5.3

源程序代码及结果....................................................

17

6.

外点处罚函数法...........................................................

24

6.1

解题思路：

..........................................................

6.2

流程框图............................................................

6.3

题目................................................................

25

6.4

7.

机械设计实质问题剖析......................................................

36

7.2

计算过程以下........................................................

7.3

源程序编写..........................................................

37

8.

报告总结..................................................................

40

1.进退法确立初始区间

1.1进退法基本思路：

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

1.2进退法程序框图

1.3题目：

用进退法求解函数fxx27x10的搜寻区间

1.4源程序代码及运转结果

#include<

stdio.h>

math.h>

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<

y2）

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黄金切割法基本思路：

经过不停的缩短单峰区间的长度来搜寻

极小点的一种有效方法。

按（0.618）减小比较f（x）大

小确立弃取区间。

2.2黄金切割法流程图

2.3题目：

对函数fxx27x9，给定搜寻区间0x8时，试用黄

金切割法求极小点

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;

b=a2;

a2=a1;

y2=y1;

end

xxx=0.5*（a+b）

f=

Inlinefunction:

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

xxx=

3.4997

3.牛顿型法

牛顿型法基本思路：

在xk邻域内用一个二次函数

x

来近

似取代原目标函数，并将

x的极小点作为对目标函数f

x求优的下一个迭

代点xk

1。

经多次迭代，使之迫近目标函数fx的极小点。

3.2阻尼牛顿法的流程图：

开始

给定x0,

k0

dk[2f（xk）]1f（xk）

xk1

xk

kdk

kk1

k:

minf（xk

dk）

3.3题目：

用牛顿阻尼法求函数fx1,x2x12

x12x2

的极小点

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;

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

fprintf（nó

?

×

è

?

á

￡?

ù

·

¨

μü

′ú

%d′?

oó

μ?

μ?

D?

x*?

°

\n'

k）;

μf?

a:

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"

stdlib.h"

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））;

n;

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

f1=objf（x[0]）;

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

f2=objf（x[1]）;

if（f2>

=f1）

{h=-h0;

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

f3=f1;

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

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

f1=f2;

f2=f3;

for（;

;

）

{h=2*h;

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

f3=objf（x[2]）;

if（f2<

f3）break;

{for（i=0;

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

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

if（h<

0）

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

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

elsefor（i=0;

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

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

free（x[i]）;

doublegold（doublea[],doubleb[],doubleeps,intn,doublexx[]）{inti;

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

for（i=0;

2;

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

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

do

{if（f1>

f2）

{for（i=0;

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

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

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

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

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

}f2=f1;

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

f1=objf（x[0]）;

q=0;

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

w=sqrt（q）;

}while（w>

eps）;

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

ff=objf（xx）;

doubleoneoptim（doublex0[],doubles[],doubleh0,doubleepsg,int

n,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（j=0;

j<

=n;

j++）

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

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

4;

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

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

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

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

f0=f1=objf（x）;

dlt=-1;

for（j=0;

{*（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;

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

if（sdx<

{free（ss）;

free（s）;

free（xx[i]）;

return（f）;

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

f2=f;

{*（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<

f1）||（q<

d））

{if（f2<

=f3）

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

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

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

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

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

for（j=m+1;

*（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）;

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源程序代码及结果：

stdlib.h>

time.h>

#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））;

请输入目标函数的维数n:

"

）;

输入已知数据*/

%d"

n）;

请输入复合形的极点数k:

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））;

/*寄存最坏点的反射点

*/

请输当选定的第一个可行点x1（包括%d个数）:

n）;

%lf"

*x+i）;

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

i++）scanf（"

a+i）;

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

b+i）;

p