《 機械優化設計 》

　實驗報告

　目錄

　 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編程相關知識,并將其應用到了約束隨機法、懲罰函數法去求解問題，收獲頗多。優化設計同時也教會了我如何追求“優”，同時使自己有能力、有辦法“化"到優!

推薦訪問： 優化設計 實驗 報告