机械优化设计实验报告Word文档格式.docx

机械优化设计实验报告Word文档格式.docx

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

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

按

（

）缩小比较

大小确定取舍区间。

黄金分割法流程图

对函数

，给定搜索区间

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

源程序代码及结果：

f=inline（'

x^2-7*x+9'

）

a=0;

b=8;

eps=;

a1=*（b-a）;

y1=f（a1）;

a2=a+*（b-a）;

y2=f（a2）;

while（abs（b-a）>

eps）

if（y1>

=y2）

a=a1;

a1=a2;

y1=y2;

a2=a+*（b-a）;

y2=f（a2）;

b=a2;

a2=a1;

y2=y1;

a1=*（b-a）;

y1=f（a1）;

end

end

xxx=*（a+b）

f=

Inlinefunction:

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

xxx=

3.牛顿型法

牛顿型法基本思路：

在

邻域内用一个二次函数

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

的极小点作为对目标函数

求优的下一个迭代点

。

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

的极小点。

阻尼牛顿法的流程图：

用牛顿阻尼法求函数

的极小点

k=0;

ptol=;

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*?

°

μf?

a:

\n'

k）;

disp（xk）;

disp（f）;

结果显示：

[1;

1]

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

4.鲍威尔法

鲍威尔法基本思路：

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

鲍威尔法流程图：

4．3题目：

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

#include"

"

#include"

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;

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;

else

{for（i=0;

if（h<

0）

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

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

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

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

free（x[i]）;

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

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

2;

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

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

do

{if（f1>

f2）

{for（i=0;

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

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

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

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

f2=f1;

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

q=0;

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

w=sqrt（q）;

}while（w>

eps）;

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

ff=objf（xx）;

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（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=*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,,,,2,x）;

printf（"

x[0]=%f,x[1]=%f,ff=%f\n"

x[0],x[1],ff）;

getchar（）;

5.复合形法

复合行法基本思想：

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

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

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

求函数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；

收敛精度ε自定义；

#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:

）;

/*输入已知数据*/

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

for（i=0;

i++）

%lf"

*x+i）;

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

i++）scanf（"

a+i）;

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

b+i）;

输出输入结果为:

\nn=%d,k=%d,x1=（"

n,k）;

/*输出已知数据*/

n-1;

%.5lf"

*（*x+i））;

%.5lf）\na=（"

*（*x+n-1））;

%f"

*（a+i））;

%.5lf）,b=（"

*（a+n-1））;

*（b+i））;

%.5lf）\n"

*（b+n-1））;

L1:

for（i=1;

k;

i++）/*随机得到其余（k-1）个可行点*/

for（j=0;

j++）

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

l=1;

for（i=1;

i++）/*找出可行点的个数l，并把可行点放在前l个位置上*/

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

{

for（j=1;

if（!

judge（*（x+j）））

{

for（k1=0;

k1<

k1++）

{

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

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

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

}

break;

}

l++;

}

for（i=0;

l-1;

i++）/*把前l个可行点按目标函数值从大到小排序*/

for（j=i+1;

l;

if（f（*（x+i））<

f（*（x+j）））

k1++）

for（i=0;

i++）/*求可行点中心*/

*（x_c+i）=0;

for（j=0;

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

for（i=0;

*（x_c+i）/=l;

if（!

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

{

for（i=0;

{

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

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

}

gotoL1;

}

else

for（i=l;

i++）/*将不可行点可行化*/

do

{

for（j=0;

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

}

while

（!

judge（*（x+i）））;

L2:

k-1;

i++）/*将可行点按目标函数值从大到小排序*/

for（j=i+1;

if（f（*（x+i））<

f（*（x+j）））

for（k1=0;

{

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

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

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

}

restrain=0;

/*求收敛条件*/

for（i=0;

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

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

if（restrain<

E0）/*判断收敛条件*/

printf（"

\n求得约束最优点为:

（"

for（i=0;

printf（"

%.5f"

*（*（x+k-1）+i））;

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

%.5f\n"

f（*（x+k-1）））;

return0;

else

L3:

i++）/*计算除去最坏点*x外的（k-1）个顶点的中心*/

*（x_c+i）=0;

for（i=1;

for（j=0;

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

for（i=0;

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

reflect=;

L4:

i++）/*求反射点*/

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

if（!

judge（x_r））

{

reflect*=;

gotoL4;

}

elseif

（f（x_r）<

f（*x））

{

for（i=0;

i++）*（*x+i）=*（x_r+i）;

gotoL2;

}

elseif（reflect<

=1e-10）

{

i++）*（*x+i）=*（*（x+1）+i）;

gotoL3;

else

reflect*=;

gotoL4;

}