机械优化设计实验报告

时间：2020-11-08 11:59:10 来源：蒲公英阅读网 本文已影响人

相关热词搜索：优化设计 实验 报告

　《 机械优化设计 》

　实验报告

　目录

　 1、进退法确定初始区间 ................................................................................. 错误! 未定义书签。

　1、1 进退法基本思路 ............................................................................. 错误! 未定义书签。

　１、2 进退法程序框图误错ﻩ 错误! 未定义书签。

　1、3 题目误错ﻩ 错误! 未定义书签。

　1、４ 源程序代码及运行结果误错ﻩ 错误! 未定义书签。

　2、黄金分割法 ................................................................................................. 错误! 未定义书签。

　2、2 黄金分割法流程图误错ﻩ 错误! 未定义书签。

　２、３ 题目误错ﻩ 错误! 未定义书签。

　2、4 源程序代码及结果 ......................................................................... 错误! 未定义书签。

　3、牛顿型法误错ﻩ 错误! 未定义书签。

　3、１牛顿型法基本思路 ......................................................................... 错误! 未定义书签。

　3、２ 阻尼牛顿法得流程图 ................................................................................................. 4 3、３ 题目 ............................................................................................... 错误! 未定义书签。

　3、4 源程序代码及结果误错ﻩ 错误! 未定义书签。

　4、鲍威尔法误错ﻩ 错误! 未定义书签。

　4、1 鲍威尔法基本思路误错ﻩ 错误! 未定义书签。

　4、2 鲍威尔法流程图误错ﻩ 错误! 未定义书签。

　4.3 题目误错ﻩ 错误! 未定义书签。

　４、4 源程序代码及结果 ....................................................................... 错误! 未定义书签。

　５、 复合形法误错ﻩ 错误! 未定义书签。

　5、1 复合行法基本思想 ......................................................................... 错误! 未定义书签。

　5、3 源程序代码及结果 ......................................................................... 错误! 未定义书签。

　6、 外点惩罚函数法误错ﻩ 错误! 未定义书签。

　6、1 解题思路：误错ﻩ 错误! 未定义书签。

　6、2 流程框图误错ﻩ 错误! 未定义书签。

　6、3 题目 ............................................................................................... 错误! 未定义书签。

　6、4 源程序代码及结果 ......................................................................... 错误! 未定义书签。

　7、机械设计实际问题分析 ............................................................................. 错误! 未定义书签。

　7、２计算过程如下误错ﻩ 错误! 未定义书签。

　7、3 源程序编写误错ﻩ 错误! 未定义书签。

　８、报告总结误错ﻩ 错误! 未定义书签。

　1 、进退法确定初始区间 1 、1

　进退法基本思路 ：

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

　1 、２ 进退法程序框图

　 １、３ 题目: :用进退法求解函数 得搜索区间

　1 、4 源程序代码及运行结果 #ｉｎcｌuｄe <stdｉo、h〉 #ｉnclude <maｔh、h〉 ｍain() ｛

　;3ａf，2aｆ，3ａ,2a,0=1a，3y，2y，１y，０ｈ,ｈ tａolfﻩ ｓcanf("h0=％f，y１=％f”，&h0,＆y1)；

　h＝h0;a２=h;y2=a2＊ａ2－7*ａ2+10;

　）１y>2ｙ（ ｆiﻩ ｛ﻩ

　h=-h;a3=a１；ｙ３=y1； loop：a1=a2;y1=y2；a2=a３；y２=ｙ３；

　}ﻩ a3=ａ2＋2＊ｈ；y3=a3*a3-7＊a3+10；

　）２y〈3y（ fiﻩ {

　 ；ｐｏoｌ otogﻩ }

　esleﻩ，2a，1a，＂n\f％=3y，f％=２y，ｆ%=１y,f%=３ａ，f％=2a，ｆ%=１ａ”（ｆtnｉｒpﻩﻩa3,ｙ1,ｙ２,y3)； ｝ 搜索区间为０

　6 2 、黄金分割法 ２、1 黄金分割法基本思路 ：

　通过不断得缩短单峰区间得长度来搜

　索极小点得一种有效方法。按() 缩小

　 比较大小

　确定取舍区间。

　 2 、2 黄金分割法流程图

　 2 、3

　题目 ：

　对函数,给定搜索区间时，试用黄金分割法求极小点

　 2 、４ 源程序代码及结果: :

　ｆ=iｎline(’x＾２—7*x+9"）

　a=0；ｂ=8；ｅｐs=0、００1;

　a1=b－0、6１8*(b—a);y1=ｆ（a１）;

　a２=ａ+0、６１8*(b—ａ）；y2=f（ａ２）;

　whiｌe(abs(b-a）＞eps)

　 iｆ（y1〉＝y2）

　 a=a1;

　 a1=ａ２;

　 y１＝y２;

　 ａ2=ａ＋0、６18＊（b-a);

　 y2＝ｆ（ａ2)；

　 else

　 ｂ=ａ２;a2=a１;y2=ｙ１;

　 a1=b-0、618＊（ｂ－a)；

　 y1=f(a1)；

　 enｄ

　end

　ｘxx=0、5＊(a+b)

　f =

　Ｉｎlinｅ functｉon：

　f（x）

　= x^2—７*x＋9 xxx =

　 3、４997 3 3 、牛顿型法

　 3 、1 牛顿型法基本思路 : : 在邻域内用一个二次函数

　来近似代替原目标函数,并将 得极小点作为对目标函数求优得下一个迭代点.经多次迭代,使之逼近目标函数得极小点。

　3 、2 阻尼牛顿法得流程图 ：

　3 、3 题目 ：

　用牛顿阻尼法求函数得极小点 3 、4 源程序代码及结果: :

　k＝0;

　pｔｏl=1、０e－5；

　xk=inｐuｔ(’inpｕt x0：’）

　itcｌ=［1；1];

　whｉlｅ nｏrm(itｃｌ）>=ptol

　f1=［4＊ｘk（1，１)^3—２4＊xｋ(1，１)^２+50*xk（1，1）—4*xk(2，１)-32；—4＊xk（1,1）+８＊ｘk（2,1）］；

　G＝［12*xk（1,1）^2—48＊xk（1，１）+50，-4；-４,8];

　dk＝－inｖ(Ｇ）*f1; a=-(dk"*ｆ1）／(dk’＊G＊dｋ)；

　xk=xk+a＊ｄk；

　开始给定结束0,  x2 1[ ( )] ( )k k kf f   d x x1:min ( )k k kkk kkf  x x dx d1 k k  x x* 1 k x x否是1 k k  0 k 

　itｃl=ａ*dk；

　k=k＋1；

　end

　f=（xk(1,１)—2）^４+(xk(1,1)－2＊xｋ（２，1））^2；

　ｆprintf（＇＼n ÓÃ×èÄáÅ£¶Ù·¨µü´ú ％d ´ÎºóµÃµ½ ¼«Ð¡µã ｘ＊¼°¼«Ð¡Öµ f Ϊ:＼n’，k）；

　disp（xk）;

　dｉsｐ（f）；

　结果显示：inpｕt ｘ０:［1;1］

　 用阻尼牛顿法迭代 27 次后得到 极小点 x＊及极小值 ｆ 为：

　2、００00

　１、0００0 １、327０e—0１9 4 、鲍威尔法

　 4 、１ 鲍威尔法基本思路 : : 在不用导数得前提下，在迭代中逐次构造 G得共轭方向。

　4 、2 鲍威尔法流程图: :

　４。3 题目 : 求函数ｆ(x）= x［0］*x[0]＋x［1]＊x［1]－x［0］＊ｘ[1]—10＊x[０］—4*x[1］+6０得最优点,收敛精度ε=０、0０1 4 、4 源程序代码及结果 ：

　#include ”stdiｏ、ｈ" ＃iｎｃlude ＂ｓｔｄｌｉb、h" ＃inｃｌｕde "maｔh、h" ｄoｕｂｌe obｊf（doｕblｅ x[］）

　｛dｏubｌｅ ff; ff=x［０］*ｘ[0]+x［1］＊x[１]—x［０]＊ｘ［1]—10＊ｘ[0]－4＊ｘ[１]+60； return(ff)；

　｝ vｏid jtf（doｕbｌｅ x0[],doubｌｅ h０，dｏuble s[],inｔ ｎ，doubｌｅ a［]，douｂｌe ｂ［]）

　｛inｔ i; doｕble ＊x[３]，h,f1，f２，f３； for（i=０;i<3;ｉ+＋）

　x［i］=(double *）malｌoc（n＊siｚｅｏf(douｂle）)； h=h0； fｏr(i=0；i〈n；i+＋）

　*（ｘ[0］+i）=x0［i］; f1=objf（x[０]）； for(i=0;ｉ<ｎ；i++) ＊（x[１］+i)=＊（x［0］+i)＋h＊s[i］; f２=objf(x［１］); ｉf(f2>=f1) {h=-h０; ｆoｒ(ｉ=0；ｉ〈n;ｉ++) *(ｘ［2］+ｉ)=＊(x［０］+i); ｆ3=ｆ1; foｒ（i=0；ｉ〈ｎ；i+＋）

　{＊(x［0]+i）=*(x[1]+i）; ＊（x［1］+ｉ)＝*（ｘ［2]+i）; } f1=ｆ2； ｆ2=f３； ｝ for（;;）

　｛ｈ=2＊ｈ; for（i＝0；i<n；ｉ++) *(x[2］+i）＝*（x［1］+i）+h＊ｓ[i]; f3=objf(ｘ[2])；

　ｉｆ（f2〈f3) bｒｅak; else ｛ for（i=0；ｉ〈ｎ；ｉ++) ｛＊(ｘ［０］+i）=＊（x[1］+i）； *(x［1］+i）=*（x［2］+i); ｝ ｆ1=ｆ2； ｆ２=f３; ｝ } ｉf（h＜0) for(ｉ=０；ｉ<n;i++）

　｛a［i］=＊（x［2］+i)； b[ｉ］=＊(ｘ［0］＋i)； ｝ elsｅ ｆoｒ(ｉ=0；i〈n；i+＋) ｛ａ［ｉ］=＊（x[0]+i）； ｂ[i］＝＊(x[2］+i）； ｝ foｒ（ｉ＝0；i＜3；i＋＋) ｆｒee(x［i]); ｝ doｕble gold（doｕble a[］,ｄouｂle b［］，dｏublｅ eps,inｔ ｎ,ｄoublｅ xx［]) ｛int i； double ｆ1,ｆ２,*x[２],ｆf，q，w； ｆｏr(i=0；ｉ〈２；i+＋) x[i]=(ｄｏuｂlｅ ＊）malloc（n*sizeof（double)）； for(i=0；ｉ<n；i++）

　｛＊（x[0］+i）=a[i］+0、６18＊（b[ｉ]—a［i］）;

　*（ｘ［１］+i）＝ａ[ｉ]+0、３82＊（b[ｉ］-a[i］）; } ｆ1=ｏbjf(x［０]); ｆ２=ｏbjf（x［1])； do {ｉf（f１＞f２）

　{ｆor(i=0；i＜n;i++）

　{b［i]=＊（x[0］＋i）； ＊（x［0]+i)=＊（ｘ［1］+i）； ｝ f1=f2； for（ｉ=０;i＜ｎ；i+＋）

　＊(x［１］＋i）=a［i］+0、3８2*（b［i］—ａ［i]）； f２=objf（x[1］）； ｝ else ｛ fｏr（i=0;i＜n;i++) ｛a［i]＝＊（ｘ［１]＋ｉ); ＊(x［1]＋i)=＊（x[0]+i);｝ f2=ｆ1； fｏr（ｉ=0;i＜n；ｉ+＋）

　＊（x［0］+i）=a［ｉ］+0、618*(b［i］-a[ｉ]）； f１＝oｂjｆ（x［０］）； ｝ q=0; ｆor(i=0;i〈ｎ；i++）

　q＝q＋(b［i]—a[i])*（b［i］－ａ[ｉ］）； ｗ＝ｓqrt(q); ｝whｉle（w〉epｓ); foｒ(ｉ=0；i<n；i++）

　xx[i］=0、５＊（a［ｉ]+b［i］）；

　ff＝ｏbjｆ（xｘ）； fｏｒ（ｉ=0；i〈２；i++) freｅ（x［i］）; ｒeturn(ff）； ｝ doｕble oneoptｉm（double x０［]，double s[］,doｕｂlｅ h0,douｂｌe ｅpsg,int n,double x[］) {dｏubｌe *a,*ｂ,ｆｆ; a=（ｄoｕbｌe *)maｌloｃ（ｎ＊ｓizeof（doublｅ）)； b=（doubｌe *)malloc(ｎ*sｉzeｏf(ｄouｂle）)； jtｆ（ｘ０,ｈ0，s，n,a，b); ｆf=gｏld(a,ｂ,ｅｐsg,n,x）; fｒee（ａ）; free(b）； rｅｔurn （ff)； } ｄouble pｏｗeｌl（douｂlｅ p[],dｏubｌｅ ｈ0,doublｅ epｓ，doublｅ epｓg，iｎｔ ｎ,doubｌe x［］) {int ｉ，j,m； doｕｂｌｅ ＊xx［4］，＊ss,＊s; doｕble f,f0,f1，f2,f3，fx，dlt，dｆ,ｓdx，ｑ，d; sｓ=(doubｌe *）malloc（n＊(n＋1）＊sizｅof（dｏuｂｌe））; ｓ＝（dｏuble *）mallｏc（n＊ｓizｅof(dｏｕblｅ)); fｏr（i=0；ｉ＜n;i＋+) ｛for(j=0；j〈＝ｎ;j++）

　*(sｓ+i＊(n＋1)+j)＝０; ＊(ｓs+i＊(n＋1)+i）=1； } for(i=0;i＜４;i＋＋）

　xx[i］＝（ｄouble ＊）mallｏc（n*sizｅｏf（douｂｌe)); foｒ（i=0；i<ｎ;i＋+)

　*(xｘ[０］+i）=p［i］； foｒ（;;）

　{fｏr（i=0；ｉ<n;i+＋）

　{*（xｘ[1]+ｉ)＝*(xx[0]+i)； x[i]=＊（xx［1］+i); } f0=f1＝ｏｂｊf（ｘ）; dlｔ=－１; for（j=0;j<ｎ；ｊ＋+）

　{ｆor（i=0;i<n;i++）

　{＊(ｘx［０］+i)=ｘ[ｉ]; *（s+ｉ)=*（sｓ＋ｉ*（n+1)＋ｊ)； ｝ f＝oneoptiｍ(ｘｘ［０]，s,ｈ0，epsg，n,x)； ｄｆ=f0—ｆ; iｆ(ｄｆ＞dlｔ) ｛dlt=ｄｆ； m＝ｊ; ｝ } sdx＝0； ｆｏr(i=0；i<n；i++）

　sdx=sdx+fabｓ(x［i］—(＊（ｘx［１]+i）））; iｆ（sdx<eps) {ｆrｅe(sｓ）； fｒee(s）; for（i=0；i〈4；i＋+）

　frｅe（ｘｘ［i］）； reｔurn（f）； ｝ for(ｉ=0;i〈ｎ;i++)

　*（ｘx［2］+i)=x[i]； ｆ2=f； for（i=0;i<ｎ;i++）

　{＊（ｘｘ［３］+i）＝２＊（＊（xｘ［２]+i)—(＊（xx［1］＋ｉ）))； x[i]＝＊（xx［3]+i)； ｝ ｆx=objf(x）; f3=fx; q=(ｆ１—２＊f２+f３)＊(f1-ｆ2-ｄlt）＊(f1－f2－dlｔ); d=0、5＊ｄｌt＊(f１-f3）*(f1-f3）； iｆ(（f3＜ｆ1)｜｜(q〈ｄ））

　{if(f2〈＝ｆ3) ｆor（i＝0；ｉ<n；i++）

　*（xx［０］+i）=*（ｘx[2］+ｉ）； ｅlse for（i=0；ｉ<n;i++) *（xx[0]+i）=＊(xx［3］＋ｉ）; } else ｛for（ｉ=0;i<n；i++) ｛*(ss＋（i＋1)*（n+１））＝ｘ[ｉ]－（*（xx［1]+i）); ＊（s+i)=*（ss＋（ｉ+１)*（n+1))； ｝ ｆ=oｎeoptim(xx［0]，s，h0，ｅpsg,n,x）; for（i=0;i<n；i＋+) ＊（xｘ［0]+i）=x[ｉ]; for（j=m+１；j〈=ｎ；j++）

　ｆｏｒ（i=0;i〈n；i＋+) *（sｓ＋i＊（ｎ+１)+j-1)=＊（sｓ+i*（ｎ+1）＋j)； } ｝

　} voｉd maiｎ（）

　｛dｏｕｂle p［］=｛1，2｝; ｄｏｕble ｆｆ,x［2］； fｆ=ｐowell(p,０、３，0、001，0、0０01，2,x); printf（"x[0]＝％ｆ，ｘ[1]=％ｆ,ff=％f＼ｎ＂，x［0］,x［1],ff）; getｃhaｒ（)； ｝

　 5 、 复合形法

　 5 、１ 复合行法基本思想 ：

　在可行域中选取 K 个设计点 （n＋1≤K≤2n）作为初始复合形得顶点。比较各顶点目标函数值得大小，去掉目标函数值最大得顶点（称最坏点)，以坏点以外其余各点得中心为映射中心,用坏点得映射点替换该点,构成新得复合形顶点。

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

　5 、2 题目: 求函数ｆ(x)=（x１-５）＊(x1—５)+４*（x２—6)*（x2－6)得最优点,约束条件为ｇ１(ｘ）=64－x１＊x1—ｘ2＊x２≤0;g2（x)=x2-x1－10≤０;g３（x)=ｘ1-10≤0;收敛精度ε自定义； 5 、3 源程序代码及结果：

　#iｎcｌude 〈sｔdｉo、h＞

　＃incluｄe 〈sｔdｌｉb、h＞

　＃inclｕｄe 〈tｉme、ｈ>

　＃iｎｃlude ＜math、ｈ>

　＃ｄefine E0 1e—5 /*复合形法收敛控制精度＊/

　ｄｏubｌe ＊＊applｙ(iｎt，int）; ／*申请矩阵空间＊/

　double f(double *); /＊目标函数＊/

　doubｌe ＊g(dｏｕble ＊）； ／＊约束函数＊/

　 bool judｇe(doublｅ ＊）； /＊可行点得判断＊/

　 ｉｎt maiｎ()

　 { iｎt n，k；

　iｎt i,j，k1；

　ｉnｔ l；

　 dｏuble tｅmpｏrarｙ；

　 doubｌe restraｉn； /＊收敛条件＊/

　doｕｂle reflect; /＊反射系数＊/

　ｓｒanｄ((uｎsigned）tｉmｅ（NＵLL））；

　 ｐrintf(”请输入目标函数得维数 n：”）； ／＊输入已知数据＊/

　 ｓcａnf(＂％d”，＆n）；

　 ｐrintf（＂请输入复合形得顶点数 ｋ：＂)；

　scanｆ（＂％d",＆k)；

　 dｏuble *＊x=applｙ(k,n); /＊存放复合形顶点＊/

　 doubｌe ＊y=（doｕｂle ＊)callｏc(k，sizeof（doublｅ)）; ／＊存放目标函数值*／

　 doｕblｅ ＊p=（doｕble *)caｌloc（３，siｚeof（double））； ／*存放约束函数值＊/

　 douｂｌe *a=(dｏubｌe ＊）calloｃ(n,sizeoｆ（ｄｏubｌe）); /*存放设计变量得下限*/

　 douｂlｅ *b＝(double ＊）calｌｏc（ｎ,sizeｏf（doｕble）); /＊存放设计变量得上限＊／

　 dｏｕble *x＿c＝(ｄoubｌｅ *）calloc（n，ｓizｅｏf（doublｅ））; /*存放可行点中心＊/

　 ｄｏuｂlｅ *x_r=（double ＊)calｌｏc（n,ｓiｚeｏｆ(dｏublｅ）)； ／＊存放最坏点得反射点＊/

　ｐｒintｆ（”请输入选定得第一个可行点 ｘ1(包含%d 个数）:”，n）;

　 ｆｏr(i=0；i<ｎ；i＋+）

　scanf（"%lf",*x+i)；

　printｆ(＂请输入初选变量得下限 a(包含%d 个数）：＂，n)；

　fｏｒ（i=0;i<n；i++) sｃａｎｆ("%lｆ”，ａ＋i）;

　 printf(＂请输入初选变量得上限 b(包含％d 个数)：＂，n)；

　 ｆor（ｉ=0；i<n；ｉ++）

　ｓcａnf(＂％lf”，b+i);

　 prinｔf（"输出输入结果为：\ｎｎ=％d，k=%d，x1=（＂,n，k）； /＊输出已知数据＊/

　 fｏr(i＝0;ｉ<n—1；i++)

　printf（”%、5lf ”,＊(*x+i）)；

　ｐriｎtf（”％、５lf）\na＝("，*(*x＋n－1）); fｏr(ｉ＝0;ｉ<ｎ-1;ｉ++）

　prｉｎtｆ(”%f ”，*(a+i））；

　printｆ（”%、5ｌｆ),b=(",*(a+n－1)）；

　for（i＝0;i＜ｎ—1;i++)

　ｐｒinｔf（"％f ”,＊(ｂ+i））；

　 prinｔf（"％、５ｌf)\n＂，＊（b＋n-１）)；

　L1: ｆor(ｉ＝1；i<k；i＋+) /＊随机得到其余（ｋ－1)个可行点＊/

　ﻩ fｏr（ｊ＝０;j＜n;j＋+）

　 ﻩ

　＊(*(x＋i)+j)=＊(a+j）+（ｄouble）（ranｄ(）％1０00０）/1０000*(＊(b+j)－＊(a+ｊ））；

　 ﻩ l＝1；

　ｆｏｒ（i=1；i〈k；i＋+) /＊找出可行点得个数 l,并把可行点放在前 ｌ 个位置上*/

　ﻩ if(ｊｕｄge(＊（x+ｉ)）)

　 ｛ﻩ ﻩ

　 ｆoｒ(j=1；ｊ<k；j＋+）

　 ﻩ

　 ﻩ iｆ(！juｄgｅ（＊(ｘ+j）））

　 ﻩﻩ ｛

　ｆor（ｋ1=0；k1<n;k1＋+)

　 ｛ﻩﻩﻩﻩﻩ ﻩ

　 ﻩﻩﻩ tｅmporａｒｙ=＊(＊（ｘ＋i）+k1);

　ﻩﻩ (*（*ﻩ；）1k+）j+x(＊(*=）1ｋ+）ｉ+ｘﻩ ﻩ

　ﻩﻩ (＊(*

　；yｒaropmｅt=）１k＋）j+xﻩﻩ ﻩ

　ﻩﻩ

　｝

　ﻩ

　 ;kａerbﻩﻩ

　} ﻩﻩﻩﻩ

　ﻩﻩ

　 ;+＋lﻩ

　 }

　 ﻩ 排小到大从值数函标目按点行可个 ｌ 前把＊／ )++ｉ；1－l<i;０=i(rｏfﻩ序*/

　）++j；l<j；１+i=j(roｆﻩﻩ ﻩﻩ

　)））j+x（*（f〈)）i+x（＊（f(fiﻩﻩ

　ﻩ

　 ﻩ ｆｏr（k1=0;ｋ1＜ｎ;ｋ1++）

　｛ﻩ ﻩﻩ

　 ﻩﻩ ｔeｍpoｒａｒy=*（＊（ｘ+i）＋ｋ１）;

　 （＊（＊ﻩ ﻩ;)1k+）ｊ+ｘ(＊（*=)1k+）i+ｘﻩ（＊(＊ﻩﻩﻩ ﻩ；yrarｏpｍet=)１ｋ+)j+xﻩ

　ﻩﻩﻩﻩ }

　 ﻩ

　 /＊心中点行可求＊/ )+＋ｉ;ｎ〈i;0=ｉ(ｒofﻩﻩ

　 ﻩﻩ

　 ＊(ｘ_c＋ｉ)＝0；

　ﻩﻩ

　 )++i；l<ｉ;0＝i(rofﻩ ﻩﻩ ）++j；ｎ<ｊ；０=j（roｆﻩﻩ

　 （＊ﻩ；）j+)i+x（*(＊＝+)j+c_xﻩ

　ﻩ

　 ﻩ

　 )++i;ｎ＜i;0=i（roｆﻩ

　 ﻩ

　ﻩﻩ

　*(x＿c+i）／=l；

　ﻩ ﻩﻩﻩ

　if(！jｕdｇe(x＿c）) /＊判断可行点中心就是否可行＊/

　ﻩ

　ﻩ ｛

　ﻩ

　ﻩ

　 ﻩ ｆor（i=0;i<n；i++）

　 ﻩ

　 ﻩﻩ

　｛ﻩ

　ﻩﻩﻩ

　 ﻩ （* ；）i+）1－l+x（＊（＊=）i+aﻩ*（b+i)＝*（x_ｃ＋i);

　 ﻩﻩ

　 ﻩ

　｝

　 ﻩﻩ

　 ﻩﻩﻩ goｔo Ｌ１；

　ﻩﻩﻩ

　｝

　ﻩﻩﻩ

　eslｅﻩ ﻩﻩ

　｛ﻩ

　 ﻩ /*化行可点行可不将*/ )+＋i;ｋ<i;l=i（ｒｏｆﻩ

　ﻩﻩﻩ odﻩﻩ

　ﻩ

　ﻩﻩ

　ﻩﻩ {

　 ﻩ

　 foｒ(ｊ=0;j＜n;j++）

　 ﻩ

　 ﻩ （＊(＊ ﻩ)j+)ｉ+x（＊(＊(*5、0+）j＋c_ｘ(*=）j+）ｉ+xﻩ－＊（ｘ_ｃ+ｊ)）;

　｝ ﻩﻩﻩﻩ ﻩﻩﻩ

　 ﻩ

　elihwﻩ ﻩ

　ﻩﻩ !（ﻩ ﻩ;))）i＋ｘ（＊(egdujﻩL2:

　/＊序排小到大从值数函标目按点行可将*／ ）++i；1－ｋ〈i；0=ｉ（ｒｏfﻩ ﻩ

　 ﻩ

　ﻩﻩ for（j=i+１；j<k；ｊ++）

　 ﻩ

　)))ｊ+x（＊(f＜)）ｉ＋x（*（f(fｉﻩﻩ

　ﻩ

　 ﻩ

　ﻩﻩ

　 )++1k;n〈１k;0＝1k（rofﻩ ﻩ ﻩﻩﻩﻩ

　ﻩﻩ

　{ﻩ

　 ﻩﻩ

　 ﻩﻩ tｅｍpｏrarｙ=*(＊(x+i）+ｋ1）；

　 ﻩﻩ

　 ﻩ

　 ﻩ

　ﻩﻩ *（＊（x+i)+ｋ1）=＊(＊（ｘ+ｊ)+k1)；

　 ﻩ

　 ﻩﻩ （＊（*ﻩ;yraｒopｍet＝）１k+)j＋xﻩ

　 ﻩﻩ

　 }ﻩﻩﻩ ﻩﻩﻩ

　 ﻩ

　 ﻩﻩﻩﻩ

　/*件条敛收求*/ ；0=ｎｉartseｒﻩ

　 ﻩ

　ﻩ

　ﻩ

　ﻩ for(ｉ＝０;i＜k；ｉ+＋)

　ﻩ

　 ﻩﻩ

　ﻩ

　 －ｋ+x(＊（f-））ｉ+x（＊(f（＝+nｉarｔseｒﻩ1)))*（f(*(x＋i））-f（*(x＋k—1)));

　 ﻩﻩ

　ﻩ

　 ﻩ

　 ;)niaｒｔｓｅr＊)1-k（/0、1(trqｓ＝niａrtｓerﻩ

　ﻩ

　 ﻩ

　ﻩ if（ｒestｒain<E０) /*判断收敛条件＊/

　 ﻩ

　ﻩﻩ

　 ﻩﻩ

　{

　 ﻩ

　 ﻩﻩ

　 ﻩﻩﻩﻩﻩ printf(＂\n 求得约束最优点为：（ ”）；

　ﻩ ﻩﻩﻩﻩﻩﻩ

　）++i；n<i；0＝ｉ（roｆﻩﻩ

　ﻩ

　 ﻩﻩﻩ priｎｔf（”％。5f ”，＊（＊（x+k—１)＋ｉ））;

　ﻩ

　ﻩ

　 ﻩﻩﻩﻩ

　ﻩﻩ ｐrintｆ（＂）\n 目标函数得最优解为:％。５f\n"，f(＊（x+k－1)))；

　 ﻩ

　ﻩﻩ ﻩﻩﻩ

　ﻩ

　；0 nｒｕterﻩﻩ

　ﻩ ﻩﻩﻩﻩﻩﻩ

　 }

　 ﻩ

　ﻩ

　ﻩ

　 eslｅﻩ ﻩ

　ﻩ

　ﻩ

　 { ﻩﻩﻩＬ3：心中得点顶个）1－k（得外 x＊点坏最去除算计＊/ ）++i;n〈i；0=i（rofﻩ＊/

　 ﻩ

　ﻩ

　ﻩﻩ

　＊（ｘ＿ｃ＋i）=０;

　 ﻩ

　ﻩ

　 ﻩ)++i；k＜i;1=i(roｆﻩ

　ﻩ

　ﻩ

　ﻩﻩ

　ﻩﻩﻩ ｆor(j=0;j<n；j++）

　 ﻩ

　ﻩ (*ﻩﻩ ﻩﻩﻩ ﻩ ;）j＋）i+x（＊(*=+)j+c_xﻩ

　 ﻩﻩﻩ

　ﻩﻩ ﻩ )++i；n<i;０=i（roｆﻩ

　ﻩﻩ

　ﻩ

　 ﻩ

　 ﻩ

　ﻩ （* ;１－k=/)i+c_xﻩ ﻩ

　ﻩﻩﻩﻩﻩﻩ

　ﻩ

　refｌect=１、３；

　L4：

　/＊点射反求＊／ )++i；n＜i;0=i（rofﻩ ﻩ ﻩﻩﻩﻩﻩﻩ ﻩﻩﻩﻩ (* ；）)i+x*（＊—)ｉ+c_x(*(*tｃeｌfer+)i+c_ｘ(＊=）i+ｒ_xﻩ

　ﻩﻩﻩﻩﻩﻩ ﻩﻩ ﻩ )）r_x(egduj！（fiﻩ

　ﻩﻩﻩ

　ﻩ

　ﻩ

　{

　 ﻩﻩ

　 ﻩﻩ ﻩ;5、0＝＊tcｅlferﻩ

　ﻩ

　ﻩ

　ﻩ;4L otogﻩ

　ﻩ

　 ｝ﻩ ﻩﻩﻩﻩﻩ ﻩﻩ

　ﻩﻩ

　ﻩ

　 fi esleﻩ ﻩ

　ﻩ

　ﻩ （ﻩ ）)x*（f〈）r_x（fﻩ

　ﻩﻩ

　｛ ﻩﻩﻩﻩﻩ

　 ﻩ ﻩﻩﻩﻩﻩ

　foｒ（i＝0；i＜ｎ；ｉ+＋）

　*（＊ｘ+i)＝＊（x_r+ｉ)；

　 ﻩﻩ

　ﻩﻩ

　goｔｏ L2；

　ﻩ

　ﻩ

　｝ﻩ

　 ﻩ

　ﻩ

　)０1-e1=〈ｔｃelfer（fi eslｅﻩ

　ﻩﻩﻩ

　｛

　ﻩﻩﻩ ﻩ ;）i＋)１+ｘ（＊(*＝）i+x＊（* )++i；n<i;0=i（rｏfﻩﻩ

　ﻩﻩﻩﻩ

　 ﻩ ;3L ｏｔｏgﻩ

　 ﻩ

　｝ﻩ ﻩ

　 ﻩﻩ

　esleﻩﻩ

　 ﻩ ﻩﻩﻩ

　 ｛

　 ﻩ

　 ；5、0＝＊tceｌfｅｒﻩ

　ﻩ

　ﻩﻩ

　 ;４L otogﻩﻩ ﻩﻩ

　ﻩﻩﻩ

　 }ﻩ ﻩ

　 ﻩﻩﻩﻩ

　 }

　 ﻩ

　ﻩﻩ ｝

　}

　douｂle *＊ａpply(ｉnｔ ｒoｗ，iｎｔ col）

　/*申请矩阵空间＊/

　 {

　；ｉ tnｉﻩ

　 ；））ｅlbuod(foｅzｉs，loｃ*wor（colｌac)*elbｕod（=x＊ elbuodﻩ

　ｄouble **y＝(dｏuble *＊）calloｃ(row,sｉzｅoｆ(dｏｕble *)）；

　ｉf(!ｘ |｜ ！y）

　｛ prｉｎtf(”内存分配失败!”）；

　eｘｉt(1);

　 }

　 ）＋+i;wｏｒ<i;０＝i(rofﻩ（＊

　 ;ｙ nrｕter ；ｌoｃ＊ｉ+x=）i+yﻩﻩ }

　 doｕblｅ f(double ＊ｘ）

　/＊目标函数*/

　 {

　rｅtｕrn (*x—5)*(*x－５)+4*(*(x+1)－6）*（＊(ｘ+1)—６）;

　}

　 ｄouble ＊g（doｕble *x) /＊约束函数*／

　 {

　doｕbｌe ＊p=（doｕｂle *)cａlloc(3，siｚeof(doublｅ））;

　 ）p!(fiﻩ

　｛ ﻩ

　 ；）”！败失配分存内”（ｆtnｉrpﻩﻩ

　 ;）1（tixeﻩ}

　＊ｐ=64—(*x)＊(*x）—(＊(ｘ+1）)＊（*（x+1)）；

　*(p+1)=*（ｘ＋1)－＊x－10;

　(＊

　 ；01—x*=)2+pﻩ

　return p；

　}

　 bool judｇe（double ＊x) /*可行点得判断*/

　 ｛

　 inｔ i；

　 ｄouｂle ＊p=（dｏublｅ *)calloc（３，ｓizeoｆ(dｏuble））;

　p=g(ｘ）；

　 for（ｉ=0；ｉ＜３；i＋+）

　fiﻩ ﻩ

　（*(p＋i)〉0）

　break；

　 if（i==3）

　retuｒｎ true；

　 elｓe rｅｔuｒn ｆａlse;

　 ｝

　６、 外点惩罚函数法 6、 、1 解题思路:外点法就是从可行域得外部构造一个点序列去逼近原约束问题得最优解。外点法可以用来求解含不等式与等式约束得优化问题。外点惩罚函数得形式为：

　6 、２

　流程框图: :

　2 21 1( , ) ( ) max[0, ( )] [ ( )]m li ji jr f r g r h     x x x x

　6 、3 题目: 求函数 f（ｘ）=(x1—5)＊(x1-5）+4*(x2－６)＊(x2-６)得最优点，约束条件:ｇ1(x)=６4-ｘ1＊x１-x２＊ｘ2≤0;g２(x)=ｘ2-x1—10≤0；g３（ｘ）=x１—１０≤0;收敛精度ε=0、０00０1;

　6 、4 源程序代码及结果 ：

　#include ＜stｄｉo、h＞ ＃ｉncluｄｅ〈ｉostreａｍ、h〉 #incｌudｅ〈mａtｈ、ｈ> doｕbｌe lamta［１0]=｛0， 1、0 ，０ ,０ ,0 ，１ ,0 ，0 ，0 ，1｝;//鲍威尔方法初始化方向,线性无关 dｏubｌe lamｔa1［3]=｛0， 0 ， ０｝;//暂存新得搜索方向 ｄouble x1[4］=｛0, 0 ,0, 0 ｝;/／x１到 x3 用于存储各共轭方向得点 ｄouble x2[4］＝{0， ０ ,0， 0 ｝； double ｘ3[4］＝｛0, 0 ，0, 0 }； ｄｏublｅ x4[4］={０， 0 ,0， ０ ｝;/／ｘ４用于中间判断 doublｅ x５［4］＝｛0， ０ ,0， 0 }；//x5 用存放于更换方向后产生得新点 int ｍ=0;//标志 dｏｕble x_［４］=｛0， 0， ０， ０};//暂存鲍威尔最优解 dｏuble x０[4］＝｛0， ２, 2 , 2｝;/／初值

　dｏuble c=１0;//递减系数

　ｄouble e＝0、0００01；//精度控制 doubｌｅ ｒ０=1；/／初始惩罚因子 dｏuble r＝１; /／函数声明部分 voｉd Powell（doublｅ r）；

　 //鲍威尔方法函数 double ｆｘy（double x1，ｄoｕｂle ｘ２,doublｅ ｘ3，douｂlｅ r);

　／/待求函数 douｂle ｙseaｒch(ｄｏｕｂle x）；

　／／一维搜索得目标函数 ｖｏid search（ｄｏｕble &a,ｄouｂle ＆b,doublｅ ｈ）；

　 //区间搜索 dｏublｅ

　yｅllｏｗcut(ｄoｕblｅ ＆ａ，double ＆b）;

　//黄金分割 voｉｄ soｒt（doｕｂle ＊p,ｉnt size)；//选择法排序 vｏid main（）

　 //约束优化方法主函数入口 {

　coｕt〈〈”请输入精度”〈〈endｌ；

　 cin>〉e； chａngyaｎ：Ｐｏwell（ｒ）;

　doubｌe cｍpaｒe［4]；

　ｉnｔ flaｇ1=0;

　for （int i=1;i〈=3；ｉ++）

　｛

　 cmｐarｅ［ｉ］=x＿[i］—ｘ０［i］;

　 if （fabｓ（cmｐare［i］)<e）

　 {flaｇ1++；}

　}

　 if （ｆlag1＝=3）

　 ｛

　priｎtｆ(”ｘ１=％lｆ

　 x2=％lf\n＂,ｘ＿［1],x_[2］); ／/

　 ｃoｕt〈〈"最优解为：＂<〈"x1=”〈〈x_[１］＜＜”

　"〈＜”x2＝"<〈ｘ_[2]〈＜"

　＂〈＜"x3="＜〈x_［３］＜〈endl ;

　cｏut〈<"最小值为"〈〈fｘy（x_［1]，x_[２］，ｘ＿［3],r)〈〈ｅndl；

　 }

　 eｌse

　 ｛

　ｆoｒ (ｉnt j=１；j<=3;j++）

　｛

　 x0[j］＝x_[ｊ];

　}

　ｒ＝ｃ＊ｒ；

　goto ｃhangｙaｎ;

　 ｝ } //子函数定义部分 double fｘy(doｕble x1，ｄoubｌe x2，ｄouｂｌe x3，doｕble r)//待求函数 ｛

　 double ｍ，ｎ,ｐ；

　ｍ=（（64—x1＊x1-x２*x2）>0)?（6４-x1*x１—x2*x2）:0；

　n=（（x２-x1-10)>0)？(x2-x1-1０）：０；

　ｐ=（（ｘ1-１0)＞0)?（x1—10):0；

　rｅｔuｒn

　／/惩罚函数 (x1-5）＊(x1—５)+4*(x２-6)＊(x2－6）+ｒ＊(m＊ｍ＋n*n+ｐ＊p）+ｒ＊（x3*x3）; ｝ ｖｏｉｄ Ｐowｅｌl(dｏuｂle r）

　 ／/鲍威尔方法函数定义 ｛

　 ｄouble dｅｔ=０、00０1；

　//迭代精度

　int k； my1：

　ｆor （k=1;k＜=3;k+＋）

　 {

　m＝3*k－2;

　double a=0,b=０，xo＝0；

　seａrch(a，b,１）；

　//完成区间搜索

　doｕｂle teｍp；

　ｔemｐ＝yellｏwcut(a，b）;//黄金分割法

　ｉnt n=3＊k-2；

　fｏr （ｉnt i=1；i＜＝3;i++）

　｛

　 sｗiｔcｈ （ｋ)

　 {

　 cａse 1:x1［i］＝x０［i］+ｔemp*lamta［n++]；breaｋ;

　 cａse 2：x2［i］=ｘ1[i]+ｔemp＊ｌamta［n＋+］；break；

　 cａse 3:x3[i］＝x2［i］+ｔeｍｐ＊lamta［ｎ+＋]；break;

　 defaｕｌt :break;

　 ｝

　}

　 }

　 doｕblｅ ｃmp[４］；

　 ｉnt ｆｌag=０;

　 fｏr (iｎｔ i=1；ｉ〈=3；ｉ++）

　 ｛

　cmp［ｉ]=x3[i］-ｘ0［i];

　ｉｆ （faｂs（ｃmp[i］)<ｄet）

　｛flａg+＋;｝｝

　 if （fｌag＝=３)

　 //找到最优解

　 ｛

　x_[1］=ｘ3[1];

　x_［2］=ｘ3［２];

　x_［3]=x3［3］;

　 ｝

　 elsｅ

　{

　doｕbｌｅ fｙ［4］;

　fy[0］=ｆxy(ｘ０［１］，x０［2］,ｘ0[3］,r)；

　ｆy［1]=ｆxy(x1[1］，ｘ１［２]，ｘ1［3］，r）；

　fｙ［2］＝fxy（x２［１］,ｘ２［2]，ｘ2［3],r）;

　fy［３］=fｘy(ｘ3［1],x3［2］，x3[3]，r）； ｄouｂle fyy[3];

　foｒ （int ii=0；iｉ＜3;iｉ＋＋)

　{fyy［ii］=fy[iｉ]—fy［ii+1］;｝

　sort（fyy，3);

　for (ii＝1；ii〈=3;ii+＋）

　｛ｘ4［ii]=2＊x3［ｉi］—x0［ii］；｝

　ｄｏuble ｆ0，f3,ｆ4；

　ｆ0=fｙ[0]；

　ｆ3＝fy[3];

　f4=fxy(ｘ４［１],ｘ４[2]，x４［３］,r）;

　ｉf （（ｆ0+ｆ4—2*f3）/2〉=fyy[2］）

　｛

　 ｉｆ （f３〈f4）

　 {

　foｒ （iｎｔ t=1；t〈=３;t＋+)

　{ｘ0［ｔ］=x3［t］；｝

　 }

　 elsｅ

　 ｛

　for (ｉnt ｔ＝１;t<=3;ｔ++）

　{x0［ｔ］=x4[ｔ］；

　 }}

　 goto my1；

　}

　elsｅ｛

　 ｆor （ｉnt t=0；t〈３;t＋+)

　 ｛lamｔa１［t］=x3[t＋１]-x０［t+1］;｝

　 m=0；

　 ／/switcｈ 标志！

　 ｄouble aa=０,bb=0;

　 seａｒch（aa，bb,1）；

　 dｏubｌe temp1;

　 temp1=yellｏｗcｕt(aa，bb)；

　 foｒ （ｉnt i=１;i〈＝3；i++）

　 ｛x5［i]=x３［i]+ｔemｐ1＊laｍta１［ｉ-１]；}

　 for (i=1;i〈=3;i＋+)

　 ｛x０［i]=x5［i]；｝

　 for （i=1；i〈=6;i++）

　 ｛ｌamta［i］=lamta［i+３];｝

　 for (ｉ=1;i<＝3；ｉ＋+）

　｛

　ｌａmtａ[6+i］=laｍtａ1［ｉ—1］；}

　 gotｏ my１； }}} doublｅ ｙsearch（ｄｏublｅ x）

　//一维搜索得目标函数 ｛ switcｈ (ｍ）

　｛ cａse 1：

　rｅtｕｒｎ fxy(ｘ０[1］＋ｘ＊laｍta[m］，x0[2]+x＊ｌamta[m+1］,x0［3］＋x*lamtａ[ｍ+２]，ｒ）；brｅak; case 4：

　ｒｅtｕrn fxy（x1［1］+ｘ*ｌａｍta[m］,x1[２］＋ｘ*lamｔａ[m+1］,x1［３］+x＊ｌaｍｔａ［m+2］，r）;ｂｒeak； ｃａse 7：

　reｔurn fxy（x2［１］+x＊lａmｔa［ｍ］，x２［2］+ｘ*lamta［ｍ+1］,ｘ2[3]+x＊lamtａ［m＋2］，r)；bｒeak； caｓe 0：

　reｔuｒｎ fxy（x３［1]+x＊laｍta1［0],x3[２]+x＊ｌamta1[1]，x3［3］＋x*lａmta1［2］，r）；bｒeak；//更改方向后得一维搜索 default：reｔurn 0; brｅaｋ; ｝ ｝ voiｄ sｅarcｈ（dｏublｅ &ａ,ｄouｂｌe &b，doubｌe ｈ)

　 //区间搜索 {double a1，a2，ａ３,y1，y2，y3; h=1； a1=a，ｙ１=yseａｒch（ａ1）; a２=a＋h,y2＝yｓｅａrcｈ(a２）； if(y２〉=ｙ1）｛

　h=-h,ａ3＝a1,ｙ3=y1；

　ａ1=a2,y1=y2,ａ2＝a3，y２=ｙ３;} ａ３=a2＋h，y3=ｙsｅaｒch（ａ３)； whilｅ(y３＜=y2)｛

　h=2＊h；

　a1=a2,y１=y2，a2=ａ3,y2=y3；

　ａ3=a2+h，ｙ3＝yｓearch(a3）; ｝ if(h〈0)a=a３，b=ａ1； else a=a１,b=a3;｝ douｂｌｅ

　ｙellowcｕt(double ＆a，double ＆b)｛

　doｕbｌe e;

　//黄金分割法求解

　e=0、001;

　double c,fc；

　c=a＋0、382*(b－ａ）；

　fc=ｙsｅarｃｈ（c）；

　dｏuble d，ｆd;

　dｏuｂle ｘｏ;

　 ｄ=ａ+0、618＊(b－a）;

　fd=yｓeａrｃh(d）; label2: if （fｃ＜=ｆd)

　 ｛b=d;

　 d=ｃ;

　 fd=fc;

　 c=ａ＋０、3８2*（ｂ—a）;

　 fc=yｓeaｒch（c)；｝

　 ｅlse

　 ｛ａ=c；

　 c=d;

　 ｆc=ｆd；

　 d=a+0、6１８*（ｂ-a)；

　 fd=ysearｃh（d）;｝

　 ｉｆ （（ｂ—a）〈=ｅ)

　 ｛xo=(a+b）/2;}

　 else

　goto label２;

　 reｔurn xo; ｝ void sｏrt(doublｅ *ｐ，iｎt ｓize)｛/／选择法排序

　ｉnt i，j；

　double k；

　foｒ(i=0;i〈ｓize-1;i+＋)

　 for（j＝i＋1；j〈size;ｊ+＋）

　ｉf(*(ｐ+i）>＊（p+ｊ））｛ｋ=＊（p+i);＊(ｐ+ｉ)=*（ｐ+j);＊（p+j）=k；} ｝

　7 、机械设计实际问题分析

　７、1 题目 : 图 示 为 一 对 称 得 两 杆 支 架 ， 在 支 架 得 顶 点 承 受 一 个 载 荷 为２ ２F F＝ ＝3 3 ０0 00 0 ０0 0

　, ,支 支 架 之 间 得 水 平 距离 离

　2 2B B= =1 1 ５2 20 0 m m, ,若 若 已 选 定 壁厚 厚T T= =2 2. . ５ m m钢 钢 管 ，密度 度p p= =8 83 30 00 0k kg g/ / m3 3, ,屈 屈 服点 点

　， ， 材 料 得 弹 性 模量 量

　。

　要 求 在 满 足 强 度 与 稳 定 性 条 件 下 设 计 最 轻 得 支 架 尺寸 寸. .

　 7 、2 计算过程如下: 解:计算压杆得临界柔度为：

　，

　由于支架为空心杆,失效形式主要为屈服,故计算稳定性用屈服极限公式。根据题意可得方程组：

　，

　代入整理得到内点混合惩罚函数法得标准形式为：

　构建惩罚函数:          kk k kr Xrx xx x r x r x r x x22 1 222122212221 ,5 . 246 . 96 86 . 84        ）

　（

　 ， 取，

　  0005 . 0 2 24 73 . 1692 11 11   kkrx xx r xx

　解得：

　令迭代精度为：，由于函数就是 X 得２次方程，故不必判别函数值得相对变化量。

　7 、3 源程序编写

　#inclｕde ＜stdio、h> ＃ｉnｃluｄe 〈math、ｈ〉 dｏｕble GetＸ3（ ｄｏｕble r) ｛

　 return （1-42*sqｒt（r)）＊（0、21*sqrt(r)+0、01＊r)／（１６8、1７2＊sqrt（r）—38*r)＋0、０025； ｝ ｄouble ＧetX4( doｕble r) ｛ rｅturｎ （0、21＊sｑｒt（r）＋0、0１*r）/(１68、１72＊sqｒt(r)-38*r)；

　} dｏuｂle F（ doublｅ ｘ3,double x4）

　{

　retｕrn 42、4315＊（x３＊x３－x4＊x4）； } main（）

　{

　 double x1=0,ｘ2=0,x3，ｘ4,r＝1,c=0、０1,ｍ＝0、000００0１；

　 inｔ i=1；

　 ｘ3=ＧetX3(r）；

　 x４=GetＸ4(r）;

　 while(1)

　 ｛

　 printf(”迭代次数：%d\n”,i）;

　ｐrｉntf（"ｒ＝％。１2f\n"，r)；

　 printf（"ｘ1=%ｆ\n”,ｘ３）；

　 prｉｎtf（"ｘ2=%ｆ\n"，ｘ４)；

　 prｉｎtf（"＼n＂）;

　 ｒ=c＊r；

　 x1＝x３;

　 ｘ2=x4；

　 x３＝GeｔＸ3(ｒ);

　 x4=GetX4（ｒ);

　 ｉｆ（（fabs（ｘ1—ｘ3）<=ｍ)＆&(ｆabs（ｘ4-x2）<＝m））

　bｒｅak；

　 i++；

　 }

　printf（＂最优解为:\ｎ＂)；

　 printf（＂R＝%f（单位:米)＼n"，x3）;

　 pｒinｔf(＂r＝％f（单位:米）\n",x4）；

　 priｎtｆ（”最小体积Ｖ＝%f（单位：立方米）＼n",F（x3,x４））；

　 return(０)； }

　 用Ｃ语言编程计算，求得结果为: 最小外径Ｒ=3.7４9mm， 最小内径 r=1.24９ｍｍ， 最小体积：v＝5３0000 立方毫米 故满足强度与稳定性条件下最轻得支架尺寸约为外径 3。75mm,内径１。25mm。

　8 、报告总结

　 通过这一段时间得学习我了解到机械优化设计就是以数学规划论为基础,以计算机为工具,一种自动寻优得先进得、现代得设计方法。根据设计所追求得性能目标，建立目标函数,在满足给定得各种约束条件下，寻求最优得设计方案.可见它就是非常经典得一门学科。再加上王卫荣老师系统全面科学得教授过程,更就是使这一学科魅力十足，强烈地吸引着我对它得深入学习与实践。

　在课程学习过程中我明白了很多工程问题就是可以转化为数学模型并可以通过计算机求解。

　同时了解了deｌphi得基本得使用技巧，并且复习了C语言与mａtlab编程相关知识,并将其应用到了约束随机法、惩罚函数法去求解问题，收获颇多。优化设计同时也教会了我如何追求“优”，同时使自己有能力、有办法“化"到优!