机械优化设计实验报告Word格式.docx
《机械优化设计实验报告Word格式.docx》由会员分享，可在线阅读，更多相关《机械优化设计实验报告Word格式.docx（26页珍藏版）》请在冰点文库上搜索。
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.黄金分割法
黄金分割法基本思路：
通过不断的缩短单峰区间的长度来搜索极小点的一种有效方法。
按
（
）缩小比较
大小确定取舍区间。
黄金分割法流程图
对函数
，给定搜索区间
时，试用黄金分割法求极小点
源程序代码及结果：
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））
{
升级会员 