鲍威尔法C++源程序
鲍威尔C程序
#include "stdio.h"#include "stdlib.h"#include "math.h"double objf(double x[]){double ff;ff=x[0]*x[0]+x[1]*x[1]-x[0]*x[1]-10*x[0]-4*x[1]+60;return(ff);}double gold(double a[],double b[],double eps,int n,double xx[]) {int i;double f1,f2,*x[2],ff,q,w;for(i=0;i<2;i++)x[i]=(double *)malloc(n*sizeof(double));for(i=0;i<n;i++){*(x[0]+i)=a[i]+0.618*(b[i]-a[i]);*(x[1]+i)=a[i]+0.382*(b[i]-a[i]);}f1=objf(x[0]);f2=objf(x[1]);do{if(f1>f2){for(i=0;i<n;i++){b[i]=*(x[0]+i);*(x[0]+i)=*(x[1]+i);}f1=f2;for(i=0;i<n;i++)*(x[1]+i)=a[i]+0.382*(b[i]-a[i]);f2=objf(x[1]);}else{ for(i=0;i<n;i++){a[i]=*(x[1]+i);*(x[1]+i)=*(x[0]+i);}f2=f1;for(i=0;i<n;i++)*(x[0]+i)=a[i]+0.618*(b[i]-a[i]);f1=objf(x[0]);}q=0;for(i=0;i<n;i++)q=q+(b[i]-a[i])*(b[i]-a[i]);w=sqrt(q);}while(w>eps);for(i=0;i<n;i++)xx[i]=0.5*(a[i]+b[i]);ff=objf(xx);for(i=0;i<2;i++)free(x[i]);return(ff);}void jtf(double x0[],double h0,double s[],int n,double a[],double b[]) {int i;double *x[3],h,f1,f2,f3;for(i=0;i<3;i++)x[i]=(double *)malloc(n*sizeof(double));h=h0;for(i=0;i<n;i++)*(x[0]+i)=x0[i];f1=objf(x[0]);for(i=0;i<n;i++)*(x[1]+i)=*(x[0]+i)+h*s[i];f2=objf(x[1]);if(f2>=f1){h=-h0;for(i=0;i<n;i++)*(x[2]+i)=*(x[0]+i);f3=f1;for(i=0;i<n;i++){*(x[0]+i)=*(x[1]+i);*(x[1]+i)=*(x[2]+i);}f1=f2;f2=f3;}for(;;){h=2*h;for(i=0;i<n;i++)*(x[2]+i)=*(x[1]+i)+h*s[i];f3=objf(x[2]);if(f2<f3) break;else{ for(i=0;i<n;i++){*(x[0]+i)=*(x[1]+i);*(x[1]+i)=*(x[2]+i);}f1=f2;f2=f3;}}if(h<0)for(i=0;i<n;i++){a[i]=*(x[2]+i);b[i]=*(x[0]+i);}elsefor(i=0;i<n;i++){a[i]=*(x[0]+i);b[i]=*(x[2]+i);}for(i=0;i<3;i++)free(x[i]);}double oneoptim(double x0[],double s[],double h0,double epsg,int n,double x[]) {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);}double powell(double p[],double h0,double eps,double epsg,int n,double x[]) {int i,j,m;double *xx[4],*ss,*s;double f,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(i=0;i<n;i++){for(j=0;j<=n;j++)*(ss+i*(n+1)+j)=0;*(ss+i*(n+1)+i)=1;}for(i=0;i<4;i++)xx[i]=(double *)malloc(n*sizeof(double));for(i=0;i<n;i++)*(xx[0]+i)=p[i];for(;;){for(i=0;i<n;i++){*(xx[1]+i)=*(xx[0]+i);x[i]=*(xx[1]+i);}f0=f1=objf(x);dlt=-1;for(j=0;j<n;j++){for(i=0;i<n;i++){*(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;for(i=0;i<n;i++)sdx=sdx+fabs(x[i]-(*(xx[1]+i)));if(sdx<eps){free(ss);free(s);for(i=0;i<4;i++)free(xx[i]);return(f);}for(i=0;i<n;i++)*(xx[2]+i)=x[i];f2=f;for(i=0;i<n;i++){*(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)for(i=0;i<n;i++)*(xx[0]+i)=*(xx[2]+i);elsefor(i=0;i<n;i++)*(xx[0]+i)=*(xx[3]+i);}else{for(i=0;i<n;i++){*(ss+(i+1)*(n+1))=x[i]-(*(xx[1]+i));*(s+i)=*(ss+(i+1)*(n+1));}f=oneoptim(xx[0],s,h0,epsg,n,x);for(i=0;i<n;i++)*(xx[0]+i)=x[i];for(j=m+1;j<=n;j++)for(i=0;i<n;i++)*(ss+i*(n+1)+j-1)=*(ss+i*(n+1)+j);}}}main(){double p[]={1,2};double ff,x[2];ff=powell(p,0.3,0.001,0.0001,2,x);printf("x[0]=%f,x[1]=%f,ff=%f\n",x[0],x[1],ff); getch();}。
鲍威尔法编程-powell法编程 c语言编程 c++6.0
for(i=0;i<N;i++)
{
printf("请输入初始点x[%d]=",i);
scanf("%f",&xo[i]);
}
printf("请输入迭代精度Ef,Ex=");
scanf("%f,%f",&c,&d);
printf("请输入步长T=");
scanf("%f",&t);
{
{
for(j=0;j<N;j++)
s[j]=ss[i][j];
}
fmin=ywyh(xooo,t,s,z);
for(j=0;j<N;j++)
x[j]=z[j];
fi[i]=fmin;
for(j=0;j<N;j++)
xooo[j]=x[j];
}
for(i=0;i<N;i++)
{
s[i]=x[i]-xoo[i];xe[i]=2*x[i]-xoo[i];
int i,j=0;
a=0;b=t;
f[0]=gs(x);
for(i=0;i<N;i++)
z[i]=x[i]+b*s[i];
f[1]=gs(z);
if(f[1]<f[0])
{
do
{t=2*t;b=b+t;f[0]=f[1];
for(i=0;i<N;i++)
z[i]=x[i]+b*s[i];
f[1]=gs(z);
matlab实验鲍威尔法
实验报告实验名称:鲍威尔法院(系):机电学院专业班级:机械制造及其自动化姓名:学号:2013年5 月13 日实验一:鲍威尔法实验日期:2013年5 月13 日一、实验目的了解MATLAB的基本运用了解MATLB在优化中的使用二、实验原理鲍威尔法也是一种共轭法,利用函数值来构造共轭方向,同时引入坐标轮换的概念,利用搜索前后两个点之间的连线形成新的共轭方向,替换旧的共轭方向。
三、实验内容鲍威尔法程序:x0=[12;10];xk=x0;ie=10^(-7);ae=1;%初始化搜索方向d=zeros(2,2);d(:,1)=[1;0];d(:,2)=[0;1];Inc=zeros(2,1);k=0;MLN=100;%迭代求解while (ae>ie&&k<MLN)syms x1syms x2xktemp=xk;fun1=fun(x1,x2);fun1=inline(fun1);f0=feval(fun1,xk(1),xk(2));F0=f0;if k>0F0=eval(F0);end%沿d1方向进行一维搜索syms asyms x1;syms x2;xk1=xk+a*d(:,1);x1=xk1(1);x2=xk1(2);fun1=fun(x1,x2);fxa=diff(fun1,'a');a=solve(fxa);xk1=inline(xk1);xk1=feval(xk1,a);xk1(1)=eval(xk1(1));xk1(2)=eval(xk1(2));syms x1;syms x2;fun1=fun(x1,x2);fun1=inline(fun1);f1=feval(fun1,xk1(1),xk1(2)); f1=eval(f1);Inc(1)=f0-f1;%沿d2方向进行搜索syms a;syms x1;syms x2;xk2=xk1+a*d(:,2);x1=xk2(1);x2=xk2(2);fun1=fun(x1,x2);fxa=diff(fun1,'a');a=solve(fxa);xk2=inline(xk2);xk2=feval(xk2,a);xk2(1)=eval(xk2(1));xk2(2)=eval(xk2(2));syms x1;syms x2;fun1=fun(x1,x2);fun1=inline(fun1);f2=feval(fun1,xk2(1),xk2(2));f2=eval(f2);F2=f2;Inc(2)=f1-f2;[Incm,row]=max(Inc);x3=2*xk2-xk;%计算反射点syms x1;syms x2;fun1=fun(x1,x2);fun1=inline(fun1);f3=feval(fun1,x3(1),x3(2));f3=eval(f3);F3=f3;temp1=(F0-2*F2+F3)*(F0-F2-Incm)^2; temp2=0.5*Incm*(F0-F3)^2;%判断是否更换搜索方向if (F3<F0&&temp1<temp2)syms a;syms x1;syms x2;d(:,row)=xk2-xk;xk=xk2+a*d(:,row);x1=xk(1);x2=xk(2);fun1=fun(x1,x2);fxa=diff(fun1,'a');a=solve(fxa);xk=inline(xk);xk=feval(xk,a);%不更换搜索方向else if F2<F3xk=xk2;elsexk=x3;endendxkerror=eval(xk2-xktemp); ae=norm(xkerror);k=k+1;endx=eval(xk)函数程序:function [f]=fun(x1,x2)f=2*x1^2+4*x1*x2+x2^2执行结果:x =四、实验小结通过本实验了解了了matlab的基本操作方法,了解鲍威尔法的原理与基本运用。
机械优化设计鲍威尔法编程
机械优化设计鲍威尔法编程鲍威尔法(Powell's method)是一种常用于机械优化设计的迭代算法,它基于步长的方向进行,进而找到局部或全局最优解。
该算法主要用于解决无约束优化问题,即不涉及约束条件的优化设计。
下面将详细介绍鲍威尔法的编程实现。
鲍威尔法的基本思路是在迭代过程中通过多次步长方向,找到全局最优解。
具体步骤如下:1.初始化:设置初始点x0和迭代次数k=0。
2.计算方向:选择一个初始的方向d0和步长α,并将d0归一化为单位向量。
3. 求解新的迭代点:通过计算当前点xk加上步长α乘以方向dk,得到新的迭代点xk+14. 更新方向:计算新的方向dk+15. 判断是否达到终止条件:如果达到了终止条件,则输出当前点xk+1为最优解;否则,令k=k+1,返回第3步继续进行迭代。
下面给出一个使用Python编程实现鲍威尔法的示例代码:```pythonimport numpy as npdef powell_method(f, x0, alpha, eps, max_iter):#初始化x=x0d = np.eye(len(x0))k=0while k < max_iter:#计算方向和步长g=f(x)d_norm = np.linalg.norm(d, axis=0) d = d / d_normalpha = alpha / d_norm#求解新的迭代点x_new = x + alpha * d#更新方向g_new = f(x_new)delta = g_new - gd = np.roll(d, -1, axis=0)d[-1] = (x_new - x) / alpha#判断终止条件if np.linalg.norm(delta) < eps: return x_new#更新迭代点x = x_newk+=1return x#示例函数,目标是求解f(x)=(x[0]-1)^2+(x[1]-2)^2 def f(x):return (x[0] - 1) ** 2 + (x[1] - 2) ** 2#设置初始点、步长、终止条件和最大迭代次数x0 = np.array([0.0, 0.0])alpha = 0.1eps = 1e-6max_iter = 100#调用鲍威尔法进行优化设计x_opt = powell_method(f, x0, alpha, eps, max_iter) #输出最优解print("Optimal solution: ", x_opt)print("Optimal value: ", f(x_opt))```在上述代码中,目标函数f(x)为示例函数,可以根据具体的优化设计问题进行修改。
优化设计-(Powell)法+鲍威尔修正算法
x2
S(k) X* X(k+1) X(k) S(j) x1
上述生成共轭方向的方法完全可以推广到 n维优 化问题中,即在 n维空间中,按上述方法可以生成 n 个相互共轭的搜索方向。 2.3.2鲍威尔法的基本原理和迭代过程 1 )采用坐标轮换法顺次沿 n个坐标轴方向进行 一维搜索,然后以初始点 X(0)和终点Xn(1)构成一个新 的方向 S(1) ,并以次方向搜索方向再作一维搜索得 到极小点Xn+1(1)。 2)取始点X0(2) = Xn+1(1),并去掉原搜索方向组 中的第一个方向 S1(1)=e1 ,而将第一轮构成的新搜索 方向 S(1) 作为最末一个方向,以此组成第二轮迭代 的n个方向。
▽f
(X(k) ) X(k)
S(j) ▽f (X(k+1) )
X(k+1) S(k)
Байду номын сангаас
[S(j) ]T ▽f (X(k) ) = 0 [S(j) ]T ▽f (X(k+1) ) = 0
具有正定对称矩阵H的二次函数
f (X) = 0.5 XT H X + BT X + C 在 X(k) 和 X(k+1)两点处的梯度可以表示为
并置 k k+1 ,返回第2)步。
鲍威尔条件:
若 f3<f1, 且 ( f1 - 2f2 + f3) (f1 - f2 - △m(k))2 < 0.5 △m(k) (f1 - f3 )2
同时成立,则用S(k)替代Sm(k) ;否则,仍用原搜索方向 组。这就是鲍威尔修正算法,通常所说的鲍威尔算法 就是指这一修正算法。
2.4.1鲍威尔算法的计算步骤及算法框图
Sm(k) = Xm(k) –Xm-1(k)
鲍威尔法C源程序
include <>include <>include <>include <>include <>include <>define n1 2define ttdefine ad//定义常量//tt 初始迭代步长//ad 收敛精度float ia;float fnyfloat x{float f;f=10powx0+x1-5,2+powx0-x1,2; //目标函数returnf;}float iteratefloat x,float a, float s{float x1;x1=float mallocn1 sizeoffloat;for int i=0;i<n1;i++x1i=xi+asi;returnx1;}float funcfloat x,float a,float s{float x1;x1=iteratex,a,s;float f=fnyx1;returnf;}void findingfloat a3,float f3,float xk,float s {float t=tt;float a1,f1;a0=0; f0=funcxk,a0,s;for int i=0;;i++{a1=a0+t; f1=funcxk,a1,s;if f1<f0break;if fabsf1-f0>=ad{t=-t;a0=a1; f0=f1;}else{if ia==1 return;t=t/2; ia=1;}}for i=0;;i++{a2=a1+t; f2=funcxk,a2,s;if f2>f1break;t=2t;a0=a1; f0=f1;a1=a2; f1=f2;}if a0>a2{a1=a0; f1=f0;a0=a2; f0=f2;a2=a1; f2=f1;}return;}//second insertfloat lagrangefloat xk,float ft,float s{float a3,f3;float b,c,d,aa;finding a,f,xk,s;for int i=0;;i++{if ia==1{aa=a1; ft=f1;break;}d=powa0,2-powa2,2a0-a1-powa0,2-powa1,2a0-a2;iffabsd==0break;c=f0-f2a0-a1-f0-f1a0-a2/d;iffabsc==0break;b=f0-f1-cpowa0,2-powa1,2/a0-a1;aa=-b/2c;ft=funcxk,aa,s;if fabsaa-a1<=ad{if ft>f1 aa=a1;break;}if aa>a1{if ft>f1{a2=aa; f2=ft;}else if ft<f1{a0=a1; a1=aa;f0=f1; f1=ft;}else if ft==f1{a2=aa; a0=a1;f2=ft; f0=f1;a1=a0+a2/2; f1=funcxk,a1,s;}}else{if ft>f1{a0=aa; f0=ft;}else if ft<f1{a2=a1; a1=aa;f2=f1; f1=ft;}else if ft==f1{a0=aa; a2=a1;f0=ft; f2=f1;a1=a0+a2/2; f1=funcxk,a1,s;}}}if ft>f1{aa=a1; ft=f1;}return aa;}float powellfloat xk{float hn1n1,sn1={0,0},ffn1+1={0,0,0};float f1,f3,aa;float dkn1,x0,xk1n1;int m=0,i,j;for i=0;i<n1;i++{forj=0;j<n1;j++{hij=0;if j==ihij=1;}}for int k=0;;k++{ff0=fnyxk;x0=xk;for i=0;i<n1;i++{for j=0;j<n1;j++sj=hij;float aa=lagrangexk,&ffi+1,s;xk=iteratexk,aa,s;}for i=0;i<n1;i++{float a,b;dki=xki-x0i;xk1i=2xki-x0i;}float max=fabsff1-ff0;for i=1;i<n1;i++if fabsffi+1-ffi>max{max=fabsffi+1-ffi;m=i;}f3=fnyxk1;if f3<ff0&&ff0+f3-2ff2powff0-ffn1-max,2<maxpowff0-f3,2 {aa=lagrangexk,&f1,dk;xk=iteratexk,aa,dk;for i=m;i<n1-1;i++for j=0;j<n1;j++hij=hi+1j;for j=0;j<n1;j++hn1-1j=dkj;}else{ifffn1>=f3 xk=xk1;}float xq=0;for i=0;i<n1;i++xq+=powxki-x0i,2;if xq<=adbreak;}returnxk;}void main{float xkn1={0,0};//取初始点float xx;xx=float mallocn1 sizeoffloat;xx=powellxk;float ff=fnyxx;cout<<"优化的结果为:"<<endl;printf"\n\nThe Optimal Design Result Is:\n";for int i=0;i<n1;i++printf"\n\t x%d =%f",i+1,xxi;printf"\n\t f=%f",ff;getch;}。
10种简单的数字滤波C语言源程序算法
10种简单的数字滤波C语言源程序算法(2009-11-09 10:25:08)假定从8位AD中读取数据(如果是更高位的AD可定义数据类型为int),子程序为get_ad();1、限幅滤波法(又称程序判断滤波法)A、方法:根据经验判断,确定两次采样允许的最大偏差值(设为A)每次检测到新值时判断:如果本次值与上次值之差<=A,则本次值有效如果本次值与上次值之差>A,则本次值无效,放弃本次值,用上次值代替本次值B、优点:能有效克服因偶然因素引起的脉冲干扰C、缺点无法抑制那种周期性的干扰平滑度差2、中位值滤波法A、方法:连续采样N次(N取奇数)把N次采样值按大小排列取中间值为本次有效值B、优点:能有效克服因偶然因素引起的波动干扰对温度、液位的变化缓慢的被测参数有良好的滤波效果C、缺点:对流量、速度等快速变化的参数不宜3、算术平均滤波法A、方法:连续取N个采样值进行算术平均运算N值较大时:信号平滑度较高,但灵敏度较低N值较小时:信号平滑度较低,但灵敏度较高N值的选取:一般流量,N=12;压力:N=4B、优点:适用于对一般具有随机干扰的信号进行滤波这样信号的特点是有一个平均值,信号在某一数值范围附近上下波动C、缺点:对于测量速度较慢或要求数据计算速度较快的实时控制不适用比较浪费RAM4、递推平均滤波法(又称滑动平均滤波法)A、方法:把连续取N个采样值看成一个队列队列的长度固定为N每次采样到一个新数据放入队尾,并扔掉原来队首的一次数据.(先进先出原则) 把队列中的N个数据进行算术平均运算,就可获得新的滤波结果N值的选取:流量,N=12;压力:N=4;液面,N=4~12;温度,N=1~4 B、优点:对周期性干扰有良好的抑制作用,平滑度高适用于高频振荡的系统C、缺点:灵敏度低对偶然出现的脉冲性干扰的抑制作用较差不易消除由于脉冲干扰所引起的采样值偏差不适用于脉冲干扰比较严重的场合比较浪费RAM5、中位值平均滤波法(又称防脉冲干扰平均滤波法)A、方法:相当于“中位值滤波法”+“算术平均滤波法”连续采样N个数据,去掉一个最大值和一个最小值然后计算N-2个数据的算术平均值N值的选取:3~14B、优点:融合了两种滤波法的优点对于偶然出现的脉冲性干扰,可消除由于脉冲干扰所引起的采样值偏差C、缺点:测量速度较慢,和算术平均滤波法一样比较浪费RAM6、限幅平均滤波法A、方法:相当于“限幅滤波法”+“递推平均滤波法”每次采样到的新数据先进行限幅处理,再送入队列进行递推平均滤波处理B、优点:融合了两种滤波法的优点对于偶然出现的脉冲性干扰,可消除由于脉冲干扰所引起的采样值偏差C、缺点:比较浪费RAM7、一阶滞后滤波法A、方法:取a=0~1本次滤波结果=(1-a)*本次采样值+a*上次滤波结果B、优点:对周期性干扰具有良好的抑制作用适用于波动频率较高的场合C、缺点:相位滞后,灵敏度低滞后程度取决于a值大小不能消除滤波频率高于采样频率的1/2的干扰信号8、加权递推平均滤波法A、方法:是对递推平均滤波法的改进,即不同时刻的数据加以不同的权通常是,越接近现时刻的数据,权取得越大。
机械优化设计——鲍威尔法
机械优化设计——鲍威尔法机械优化设计班级:0841001成员:张波2010213217张建2010213214潘阳瑞20102132272013年6月鲍威尔法鲍威尔(Powell)法是直接利用函数值来构造共轭方向的一种方法。
基本思想:在不用导数的前提下,在迭代中逐次构造G 的共轭方向。
一(基本算法:(二维情况描述鲍威尔的基本算法)0T1)任选一初始点x,再选两个线性无关的向量,如坐标轴单位向量e=[1,0]和1T=[0,1]作为初始搜索方向。
e20002)从出发,顺次沿、作一维搜索,得、点,两点连线得一新 xeexx12121001方向 d,x,xd2011 用代替e形成两个线性无关向量,e,作为下一轮迭代的搜索方向。
再从xdd1,1201出发,沿作一维搜索得点,作为下一轮迭代的初始点。
xd111113)从出发,顺次沿、作一维搜索,得到点、,两点连线得一新方向: exxxd122211。
d,x,x21*22沿作一维搜索得点,即是二维问题的极小点。
xdx把二维情况的基本算法扩展到n维,则鲍威尔基本算法的要点是:在每一轮迭代中总有一个始点(第一轮的始点是任选的初始点)和n个线性独立的搜索方向。
从始点出发顺次沿n个方向作一维搜索得一终点,由始点和终点决定了一个新的搜索方向。
用这个方向替换原来n个方向中的一个,于是形成新的搜索方向组。
替换的原则是去掉原方向组的第一个方向而将新方向排在原方向的最后。
此外规定,从这一轮的搜索终点出发沿新的搜索方向作一维搜索而得到的极小点,作为下一轮迭代的始点。
这样就形成算法的循环。
图1.二维情况下的鲍威尔法二(改进算法在鲍威尔基本算法中,每一轮迭代都用连结始点和终点所产生出的搜索方向去替换原向量组中的第一个向量,而不管它的“好坏”,这是产生向量组线性相关的原因所在。
在改进的算法中首先判断原向量组是否需要替换。
如果需要替换,还要进一步判断原向量组中哪个向量最坏,然后再用新产生的向量替换这个最坏的向量,以保证逐次生成共轭方向。
C语言经典源程序100例
C语言经典源程序100例1. Hello, World!这是C语言中最基本的程序,用于显示"Hello, World!"。
```c#include <stdio.h>int main() {printf("Hello, World!\n");return 0;}```2. 计算两数之和这个程序用于计算两个整数的和,并将结果输出。
```c#include <stdio.h>int main() {int num1, num2, sum;printf("请输入两个整数:");scanf("%d %d", &num1, &num2);sum = num1 + num2;printf("两数之和为:%d\n", sum);return 0;}```3. 判断奇偶数这个程序用于判断一个整数是奇数还是偶数。
```c#include <stdio.h>int main() {int num;printf("请输入一个整数:");scanf("%d", &num);if (num % 2 == 0) {printf("该数是偶数。
\n");} else {printf("该数是奇数。
\n");}}```4. 求输入数字的平均值这个程序用于求输入数字的平均值。
```c#include <stdio.h>int main() {int count, i;double num, sum = 0.0, average;printf("请输入数字的个数:");scanf("%d", &count);printf("请输入这 %d 个数字:\n", count); for (i = 0; i < count; i++) {scanf("%lf", &num);sum += num;}average = sum / count;printf("平均值为:%lf\n", average);}```5. 判断闰年这个程序用于判断一个年份是否为闰年。
鲍威尔法VB程序设计
鲍威尔法实验报告姓名:刘阳阳学号:1201013009鲍威尔法程序设计1 方法(算法)介绍1.1 方法原理简介鲍威尔法——多维无约束优化算法是在无约束优化算法之一,首先选取一组共轭方向,从某个初始点出发,求目标函数在这些方向上的极小值点,然后以该点为新的出发点,重复这一过程直到获得满意解,其优点是不必计算目标函数的梯度就可以在有限步内找到极值点。
鲍威尔法是以共轭方向为基础的收敛较快的直接法之一,是一种十分有效的算法。
在无约束方法中许多算法都是以共轭方向作为搜索方向,它们具有许多特点。
根据构造共轭方向的原理不同,可以形成不同的共轭方向法。
基本算法1)任选一初始点x0,再选两个线性无关的向量,如坐标轴单位向量e1=[1,0]T 和e2=[0,1]T作为初始搜索方向。
2)从x0出发,顺次沿e1,e2作一维搜索,得x10,x20点,两点连线得一新方向d1=x20-x0。
用d1代替e1形成两个线性无关向量d1 ,e2 ,作为下一轮迭代的搜索方向。
再x20 出发,沿d1 作一维搜索得点x01,作为下一轮迭代的初始点。
3)从x1 出发,顺次沿,e2。
d1 作一维搜索,得到点x11,x21,两点连线得一新方向:d2=x21-x11。
4)沿d2d2作一维搜索得点.x2 ,即是二维问题的极小点x*把二维情况的基本算法扩展到n维,则鲍威尔基本算法的要点是:在每一轮迭代中总有一个始点(第一轮的始点是任选的初始点)和n个线性独立的搜索方向。
从始点出发顺次沿n个方向作一维搜索得一终点,由始点和终点决定了一个新的搜索方向。
用这个方向替换原来n个方向中的一个,于是形成新的搜索方向组。
替换的原则是去掉原方向组的第一个方向而将新方向排在原方向的最后。
此外规定,从这一轮的搜索终点出发沿新的搜索方向作一维搜索而得到的极小点,作为下一轮迭代的始点。
这样就形成算法的循环。
1.2 程序设计框图1.3程序说明本程序使用VB程序语言设计,在该程序中插入command模块picture模块利用矩阵函数语句迭代计算出鲍威尔最小值并将之在picture模块中显示出2 例题计算2.1 例题:用鲍威尔法求f(x1,x2)=10*(x1+x2-5)^2+(x1-x2)^22.2 计算结果与分析VB程序计算结果如图:经演算迭代后得到结果为:X0^2= 2.49952.5091 F0=f0(x0^2)=0.0008可见已足够接近极值点x*=(2.5,2.5)T 及极小值f(x*)=02.3 结论经验算鲍威尔法VB程序计算结果正确且为最优解。
C语言程序设计100例之(46):巧妙称重
C语⾔程序设计100例之(46):巧妙称重例46 巧妙称重题⽬描述有N个篮⼦,编号1~N,篮⼦中有很多⾦币,每个重w。
但是有⼀个编号的篮⼦中,每个⾦币重d。
现从第⼀个篮⼦中拿1个⾦币,第⼆个篮⼦中拿2个,…,第N-1中拿N-1个,第N中不拿,给出这些⾦币的总重量wei,问:是第⼏个篮⼦中的⾦币重量较轻?输⼊格式输⼊⽂件将由⼀⾏或多⾏组成;每⾏包含四个正整数,由⼀个空格分隔。
前三个整数分别是数字N、w和d,如上所述。
第四个整数是所选硬币称重的结果。
N⾄少为2,但不超过8000。
w的值最多为30。
d的值将⼩于w。
输出格式对于每组测试数据输出⼀⾏,由⼀个正整数组成:装有⽐其他篮⼦中⾦币轻的⾦币的篮⼦编号。
输⼊样例10 25 8 110910 25 8 10458000 30 12 959879400输出样例21050(1)编程思路。
这是⼀道数学题分析题。
若设1~N-1这N-1个篮⼦中放的⾦币均为重量为w的⾦币,则应有的总重量为:w*(1+n-1)*(n-1)/2(简单的等差数列求和),所求的和减去实际称出的重量wei,得到⾦币重量的差值sum = ((n-1)*(n-1+1)/2)*w-wei。
若sum为0,则装有重量为d的篮⼦编号必为N;若sum不为0,除以d,得到较轻⾦币的个数,即为所求编号。
(2)源程序。
#include <stdio.h>int main(){int n,w,d,p;while (scanf("%d%d%d%d",&n,&w,&d,&p)!=EOF){int sum = ((n-1)*(n-1+1)/2)*w-p;if(sum==0)printf("%d\n",n);elseprintf("%d\n",sum/d);}return 0;}习题4646-1 ⿁⾕⼦的钱袋题⽬描述⿁⾕⼦⾮常聪明,正因为这样,他⾮常繁忙,经常有各诸侯车的特派员前来向他咨询时政。
鲍威尔法编程-powell法编程c语言编程c++6.0.doc
数字信号处理实验讲义前言 (2)实验一MA TLAB简介 (3)实验二用FFT实现信号的谱分析 (5)实验三IIR数字巴特沃思滤波器的设计 (8)实验四FIR数字滤波器的设计 (9)前言信号处理与计算机的应用紧密结合。
目前广泛应用的MA TLAB工具软件包,以其强大的分析、开发及扩展功能为信号处理提供了强有力的支持。
在数字信号处理实验中,我们主要应用MA TLAB的信号处理工具箱及其灵活、便捷的编程工具,通过上机实验,帮助学生学习、掌握和应用MA TLAB软件对信号处理所学的内容加以分析、计算,加深对信号处理基本算法的理解。
实验一 MATLAB 简介实验目的1.熟悉MA TLAB 软件的使用方法; 2.MA TLAB 的绘图功能;3.用MA TLAB 语句实现信号的描述及变换。
实验原理1.在MA TLAB 下编辑和运行程序在MA TLAB 中,对于简单问题可以在命令窗(command windows )直接输入命令,得到结果;对于比较复杂的问题则可以将多个命令放在一个脚本文件中,这个脚本文件是以m 为扩展名的,所以称之为M 文件。
用M 文件进行程序的编辑和运行步骤如下:(1)打开MA TLAB ,进入其基本界面;(2)在菜单栏的File 项中选择新建一个M 文件;(3)在M 文件编辑窗口编写程序;(4)完成之后,可以在编辑窗口利用Debug 工具调试运行程序,在命令窗口查看输出结果;也可以将此文件保存在某个目录中,在MA TLAB 的基本窗口中的File 项中选择Run The Script ,然后选择你所要运行的脚本文件及其路径,即可得出结果;也可以将此文件保存在当前目录中,在MA TLAB 命令窗口,“>>”提示符后直接输入文件名。
2.MA TLAB 的绘图功能plot(x,y) 基本绘图函数,绘制 x 和y 之间的坐标图。
figure(n ) 开设一个图形窗口nsubplot(m,n,N) 分割图形窗口的MA TLAB 函数,用于在一个窗口中显示多个图形,将图形窗口分为m 行n 列,在第N 个窗口内绘制图形。
鲍威尔法C语言
鲍威尔法C语言鲍威尔法C语言程序#include <stdio.h>#include <math.h>#define m 10 /*数组长度m >= 维数n */float f(float x[]);void mjtf(int n,float x0[],float h,float s[],float a[],float b[]);void mhjfgf(int n,float a[],float b[],float flag,float x[]);void mbwef(int n,float x0[],float h,float flag,float a[],floatb[],float x[]);float f(float x[]){float result;result=60-10*x[0]-4*x[1]+x[0]*x[0]+x[1]*x[1]-x[0]*x[1];return result; }/*多维进退法子程序*/void mjtf(int n,float x0[],float h,float s[],float a[],float b[]) {int i;float x1[m],x2[m],x3[m],f1,f2,f3;for(i=0;i<n;i++) /*计算初始两试点*/{x1[i]=x0[i];x2[i]=x0[i]+h*s[i];}f1=f(x1);f2=f(x2);if(f2>=f1) /*判断搜索方向*/{ /*搜索方向为反向,转身*/h=(-1)*h;for(i=0;i<n;i++)x3[i]=x1[i];f3=f1;for(i=0;i<n;i++)x1[i]=x2[i];f1=f2;for(i=0;i<n;i++)x2[i]=x3[i];f2=f3;} /*搜索方向为正向*/for(i=0;i<n;i++) /*计算第三试点*/x3[i]=x2[i]+h*s[i];f3=f(x3);while(f3<f2) /*判断是否未完成搜索*/ { /*未完成,继续搜索*/h=2*h;for(i=0;i<n;i++)x1[i]=x2[i];f1=f2;for(i=0;i<n;i++)x2[i]=x3[i];f2=f3;for(i=0;i<n;i++)x3[i]=x2[i]+h*s[i];f3=f(x3);} /*已完成*/for(i=0;i<n;i++) /*输出初始搜索区间*/{if(x1[i]<x3[i]){a[i]=x1[i]; b[i]=x3[i];}else{a[i]=x3[i];b[i]=x1[i];}}}/*多维黄金分割法子程序*/void mhjfgf(int n,float a[],float b[],float flag,float x[]){int i;float x1[m],x2[m],f1,f2,sum;for(i=0;i<n;i++) /*计算初始两试点*/ x1[i]=b[i]-(float)0.618*(b[i]-a[i]); f1=f(x1);for(i=0;i<n;i++)x2[i]=a[i]+(float)0.618*(b[i]-a[i]); f2=f(x2);do{if(f1<=f2) /*判断消去区间*/{ /*消去右*/for(i=0;i<n;i++){mjtf(n,x1,h,s[i],a,b);mhjfgf(n,a,b,flag,x1);fn[i]=f(x0)-f(x1);}for(i=0;i<n;i++)x2[i]=2*x1[i]-x0[i];for(i=1;i<n;i++)if(fn[0]<fn[i]){fn[0]=fn[i];r=i;}elser=0;f0=f(x0);f1=f(x1);f2=f(x2);if(f2>=f0||(f0-2*f1+f2)*(f0-f1-fn[0])*(f0-f1-fn[0])>=0.5*fn[0]*(f0-f2)*(f0-f2)){sum=0;for(i=0;i<n;i++)sum+=(x1[i]-x0[i])*(x1[i]-x0[i]);if(f1<=f2) for(i=1;i<n;i++)x0[i]=x1[i];elsefor(i=1;i<n;i++)x0[i]=x2[i];}else{ for(i=r;i<n;i++)for(j=0;j<n;j++)s[i][j]=s[i+1][j];for(i=0;i<n;i++)s[n][i]=x1[i]-x0[i];mjtf(n,x1,h,s[n],a,b);mhjfgf(n,a,b,flag,x1);sum=0; for(i=0;i<n;i++)sum+=(x1[i]-x0[i])*(x1[i]-x0[i]); for(i=0;i<n;i++)x0[i]=x1[i];}if(sqrt(sum)<=flag) break;elsek+=1;}for(i=0;i<n;i++)x[i]=x1[i];}/*鲍威尔法主程序*/void main(){int i,n;float h,flag,x0[m],a[m],b[m],x[m]; printf("\n<鲍威尔法>\n");printf("请输入维数:\n");scanf("%d",&n);printf("请输入初始点:");for(i=0;i<n;i++){printf("\nx0[%d]=",i);scanf("%f",&x0[i]);}printf("\n请输入初始步长:\n"); scanf("%f",&h);printf("\n请输入精度:\n");scanf("%f",&flag);mbwef(n,x0,h,flag,a,b,x);printf("\n极小点坐标为:\n");for(i=0;i<n;i++)printf("x[%d]=%f\n",i,x[i]);printf("\n极小值为:\n%f\n",f(x)); }。
10种简单的数字滤波算法(C语言源程序)
10种简单的数字滤波算法(C语言源程序)1、限幅滤波法(又称程序判断滤波法)A、方法:根据经验判断,确定两次采样允许的最大偏差值(设为A)每次检测到新值时判断:如果本次值与上次值之差<=A,则本次值有效如果本次值与上次值之差>A,则本次值无效,放弃本次值,用上次值代替本次值B、优点:能有效克服因偶然因素引起的脉冲干扰C、缺点无法抑制那种周期性的干扰平滑度差#define A 10char value;char filter(){char new_value;new_value = get_ad();if ( ( new_value - value > A ) || ( value - new_value > A )return value;return new_value;}2、中位值滤波法A、方法:连续采样N次(N取奇数)把N次采样值按大小排列取中间值为本次有效值B、优点:能有效克服因偶然因素引起的波动干扰对温度、液位的变化缓慢的被测参数有良好的滤波效果C、缺点:对流量、速度等快速变化的参数不宜#define N 11char filter(){char value_buf[N];char count,i,j,temp;for ( count=0;count<N;count++){value_buf[count] = get_ad();delay();}for (j=0;j<N-1;j++){for (i=0;i<N-j;i++){if ( value_buf[i]>value_buf[i+1] ){temp = value_buf[i];value_buf[i] = value_buf[i+1];value_buf[i+1] = temp;}}}return value_buf[(N-1)/2];}3、算术平均滤波法A、方法:连续取N个采样值进行算术平均运算N值较大时:信号平滑度较高,但灵敏度较低N值较小时:信号平滑度较低,但灵敏度较高N值的选取:一般流量,N=12;压力:N=4B、优点:适用于对一般具有随机干扰的信号进行滤波这样信号的特点是有一个平均值,信号在某一数值范围附近上下波动C、缺点:对于测量速度较慢或要求数据计算速度较快的实时控制不适用比较浪费RAM#define N 12char filter(){int sum = 0;for ( count=0;count<N;count++){sum + = get_ad();delay();}return (char)(sum/N);}4、递推平均滤波法(又称滑动平均滤波法)A、方法:把连续取N个采样值看成一个队列队列的长度固定为N每次采样到一个新数据放入队尾,并扔掉原来队首的一次数据.(先进先出原则)把队列中的N个数据进行算术平均运算,就可获得新的滤波结果N值的选取:流量,N=12;压力:N=4;液面,N=412;温度,N=14B、优点:对周期性干扰有良好的抑制作用,平滑度高适用于高频振荡的系统C、缺点:灵敏度低对偶然出现的脉冲性干扰的抑制作用较差不易消除由于脉冲干扰所引起的采样值偏差不适用于脉冲干扰比较严重的场合比较浪费RAM#define N 12char value_buf[N];char i=0;char filter(){char count;int sum=0;value_buf[i++] = get_ad();if ( i == N ) i = 0;for ( count=0;count<N,count++)sum = value_buf[count];return (char)(sum/N);}5、中位值平均滤波法(又称防脉冲干扰平均滤波法)A、方法:相当于“中位值滤波法”+“算术平均滤波法”连续采样N个数据,去掉一个最大值和一个最小值然后计算N-2个数据的算术平均值N值的选取:3~14B、优点:融合了两种滤波法的优点对于偶然出现的脉冲性干扰,可消除由于脉冲干扰所引起的采样值偏差C、缺点:测量速度较慢,和算术平均滤波法一样比较浪费RAM#define N 12char filter(){char count,i,j;char value_buf[N];int sum=0;for (count=0;count<N;count++) {value_buf[count] = get_ad(); delay();}for (j=0;j<N-1;j++){for (i=0;i<N-j;i++){if ( value_buf[i]>value_buf[i+1] ) {temp = value_buf[i];value_buf[i] = value_buf[i+1]; value_buf[i+1] = temp;}}}for(count=1;count<N-1;count++) sum += value[count];return (char)(sum/(N-2));}6、限幅平均滤波法A、方法:相当于“限幅滤波法”+“递推平均滤波法”每次采样到的新数据先进行限幅处理,再送入队列进行递推平均滤波处理B、优点:融合了两种滤波法的优点对于偶然出现的脉冲性干扰,可消除由于脉冲干扰所引起的采样值偏差C、缺点:比较浪费RAM略参考子程序1、37、一阶滞后滤波法A、方法:取a=0~1本次滤波结果=(1-a)本次采样值+a上次滤波结果B、优点:对周期性干扰具有良好的抑制作用适用于波动频率较高的场合C、缺点:相位滞后,灵敏度低滞后程度取决于a值大小不能消除滤波频率高于采样频率的1/2的干扰信号#define a 50char value;char filter(){char new_value;new_value = get_ad();return (100-a)value + a new_value;}8、加权递推平均滤波法A、方法:是对递推平均滤波法的改进,即不同时刻的数据加以不同的权通常是,越接近现时刻的数据,权取得越大。
MATLAB关于Powell优化设计程序
f0 = X0_1(1)^2+2*X0_1(2)^2-4*X0_1(1)-2*X0_1(1)*X0_1(2); % 初始点的函数值.
Dt1_1 = f0-f1; % 计算本轮相邻两点函数值的下降量. Dt2_1 = f1-f2; Dtm_1 = max(Dt1_1,Dt2_1); % 进行收敛判断(是否用得到的第一个共轭方向替换上一轮中的第一个一维搜索方向). if (F3<F1&&(F1+F3-2*F2)*(F1-F2-Dtm_1)^2<0.5*Dtm_1*(F1-F3)^2) S1_2 = S2_1; S2_2 = S_1; else S1_2 = S2_1; S2_2 = S1_1; end syms a3 % 以下语句是求出沿S_1方向进行一维搜索的最佳步长因子以及第二轮迭代的初始点X0_2. X_1 = X2_1+a3*S_1; f3 = X_1(1)^2+2*X_1(2)^2-4*X_1(1)-2*X_1(1)*X_1(2); ff3 = diff(f3); a3 = solve(ff3,0); % 求得沿S_1方向进行一维搜索的最优步长 a3. X_1 = X2_1+a3*S_1; f3 = eval(X_1(1)^2+2*X_1(2)^2-4*X_1(1)-2*X_1(1)*X_1(2)); % 得到第二轮迭代的初始点X_1处的函数值. X0_2 =eval(X_1); F_1 = f3; % 进行迭代终止检验 d1 = sqrt((X0_2(1)-X0_1(1))^2+(X0_2(2)-X0_1(2))^2); if (d1>E) % 得到d1 = 2.886173937932362 fprintf('第一轮迭代完成过后的精度检验值为:d1 = %4f\n',d1) % 进行迭代终止检验是否继续进行下一轮迭代 % 第二轮迭代(K=2!) % 沿S2_1方向进行第二轮迭代第一次一维搜索 syms a4 % 以下语句是求出沿S1_2方向进行一维搜索的最佳步长因子 X1_2 = X0_2+a4*S1_2; f4 = X1_2(1)^2+2*X1_2(2)^2-4*X1_2(1)-2*X1_2(1)*X1_2(2); ff4 = diff(f4); a4 = solve(ff4,0);% 得到第二轮迭代第一次一维搜索的最优步长因子a4. fprintf('第二轮迭代第一次一维搜索的最优步长因子为: a4 = %4f\n',eval(a4)) X1_2 = X0_2+a4*S1_2; f4 = eval(X1_2(1)^2+2*X1_2(2)^2-4*X1_2(1)-2*X1_2(1)*X1_2(2)); % 得到第二轮迭代点X1_2处的函数值f4. % 沿S2_2方向进行第二轮迭代第二次一维搜索 syms a5 X2_2 = X1_2 + a5*S2_2; f5 = X2_2(1)^2+2*X2_2(2)^2-4*X2_2(1)-2*X2_2(1)*X2_2(2); ff5 = diff(f5); % 得到第二轮的迭代初始点X0_2.
C语言中的概率算法实现
C语言中的概率算法实现概率算法是计算机科学中常用的一种算法,用于处理随机事件的概率分布和概率计算。
在C语言中,我们可以使用各种技术和方法来实现概率算法。
本文将介绍C语言中常用的概率算法实现方式和示例代码。
一、伪随机数生成器在概率算法中,伪随机数生成器(pseudo-random number generator)是一种常用的工具。
它可以生成接近于真正随机数的数列,用于模拟随机事件的概率分布。
C语言中提供了许多生成伪随机数的函数,比如rand()函数,该函数可以生成一个在范围[0, RAND_MAX]之间的整数。
示例代码:```c#include <stdio.h>#include <stdlib.h>#include <time.h>int main() {int i, n;srand(time(0)); // 初始化随机数种子printf("生成10个随机数:");for (i = 0; i < 10; i++) {n = rand();printf("%d ", n);}return 0;}```在上述示例代码中,使用srand()函数初始化随机数种子,使用rand()函数生成随机数。
二、概率分布函数为了实现具体的概率算法,我们通常需要使用概率分布函数(probability distribution function),它描述了随机事件的概率分布情况。
C语言中提供了一些常用的概率分布函数,比如均匀分布、正态分布等。
示例代码:```c#include <stdio.h>#include <stdlib.h>#include <time.h>double uniform_distribution() {return (double)rand() / RAND_MAX; // 生成[0, 1)之间的均匀分布随机数}double normal_distribution(double mean, double stddev) {double u = uniform_distribution();double v = uniform_distribution();double z = sqrt(-2 * log(u)) * cos(2 * M_PI * v);return mean + stddev * z; // 生成均值为mean,标准差为stddev的正态分布随机数}int main() {int i;srand(time(0));printf("生成10个均匀分布随机数:");for (i = 0; i < 10; i++) {double n = uniform_distribution();printf("%lf ", n);}printf("\n生成10个正态分布随机数:");for (i = 0; i < 10; i++) {double n = normal_distribution(0, 1);printf("%lf ", n);}return 0;}```在上述示例代码中,uniform_distribution()函数生成[0, 1)之间的均匀分布随机数,normal_distribution()函数生成均值为mean,标准差为stddev的正态分布随机数。
优化设计 鲍威尔算法Microsoft Word 文档
第一个程序1:#include<stdio.h>#include<math.h>#define TOL 1.0e-3#define m 10#define RUN#define n 2float golden(float a[], float b[], float c[], float tol,floatxmin[]);voidmnbrak(float a[], float b[], float c[],float d[], float *fa, float *fb, float *fc);floatfunc(float x[]){float result;result=60-10*x[0]-4*x[1]+x[0]*x[0]+x[1]*x[1]-x[0]*x[1];//result=10*(float)pow((x[0]+x[1]-5),2)+(float)pow((x[0]-x[1]),2);return result;}float main(void){inti,k,j,v=0,dmax=0,flag=0;floate,l,a[m],a1[m],a2[m],a3[m],b[m],c[m],d[m],d1[m][m],fa,fb,fc,xmin[m],xmin2[m],gold,amin,ac=0, x[m];printf("鲍威尔求二维函数最小值:\n");#ifdef RUNprintf("输入初始点:");for(i=0;i<n;i++){printf("\na[%d]=",i);scanf("%f",&a[i]);}for(k=0;k<n;k++){printf("\n输入初始搜索方向%d:\n",i);for(j=0;j<n;j++){printf("\nd%d[%d]=",k,j);scanf("%f",&d1[k][j]);}}printf("输入搜索精度e:\n");scanf("%f",&e);#endif#ifndef RUNfor(i=0;i<n;i++)a[i] = 0;d1[0][0] =1;d1[0][1]=0;d1[1][0]=0;d1[1][1]=1;e=0.001;#endif//开始进行搜索//// printf("开始进行最小搜索\n");for(v=0;v<10000;v++)//一共最多进行10000次搜索{ //printf("已开始进行%d轮搜索\n",v+1);for(i=0;i<n;i++)a1[i]=a[i];//保存起始点a[]for(k=0;k<n;k++)//分别对所给方向进行搜索共n次{ //printf("已开始进行第%d个方向的搜索\n",k);for(j=0;j<n;j++){d[j]=d1[k][j];//printf("tiaoshi");a2[j]=a[j];}//printf("tiaoshi");//保存每次搜索的起点用于计算差值mnbrak(a,b,c,d,&fa,&fb,&fc);gold=golden(a,b,c,TOL,xmin);for(i=0;i<n;i++)//替换起点a[]准备下次搜索的起点a[i]=xmin[i];amin=gold-func(a2);//amin中间点的差值if(flag==0){ac=amin;flag=1;}if(ac<amin){ac=amin;//ac储存n个中最大差值dmax=k;//储存n次中差值最大的搜索方向。
机械优化设计鲍威尔法编程
鲍威尔法求解二维函数极小值的程序说明一题目利用鲍威尔法求函数221212112(,)242f x x x x x x x =+--的极小值点。
二鲍威尔法基本思想:1) 给定初始点0x ,选取初始方向组,它由n 各线性无关的向量00012,...n d d d 所组成。
2) 从0k x 出发,顺次沿12,,...k k k n d d d 作一维搜索得12,,...k k k n x x x 。
接着以k n x 为起点,沿方向10k k k n n d x x +=-移动一个0k k n x x -的距离,得到01,,k k k n n x x x +分别称为一轮迭代的始点,终点和反射点。
始点,终点,反射点所对应的函数值分别表示为同时计算各中间点处的函数值,并记为因此有002,n F f F f ==计算n 个函数值之差,记作1i i i f f -∆=-其中最大者记作1max m i m m f f -∆=∆=-3) 根据是否满足判别条件和来确定是否要对原方向组进行替换。
若不满足判别条件,则下轮迭代应对原方向组进行替换,将1k n d +补充到原方向组的最后位置,而除掉k m d 。
即新方向组为1k d ,2k d ,…,1k m d -,1k m d +,…,k n d ,1k n d +作为下轮迭代的搜索方向。
下轮迭代的始点取1k n d +方向进行一维搜索得极小点10k x +。
4) 判断是否满足收敛准则。
若满足则取10k x +为极小点,否则应置1k k =+,返回2,继续进行下一轮迭代。
改进后的鲍威尔法程序框图如下:三用鲍威尔法求函数程序如下:"#include"鲍威尔法"#ifdef_DEBUG#definenewDEBUG_NEW#undefTHIS_FILEstaticcharTHIS_FILE[]=__FILE__;#endif."menuitemtosystemmenu.ASSERT((IDM_ABOUTBOX&0xFFF0)==IDM_ABOUTBOX);ASSERT(IDM_ABOUTBOX<0xF000);CMenu*pSysMenu=GetSystemMenu(FALSE);if(pSysMenu!=NULL){CStringstrAboutMenu;(IDS_ABOUTBOX);if(!()){pSysMenu->AppendMenu(MF_SEPARATOR);pSysMenu->AppendMenu(MF_STRING,IDM_ABOUTBOX,strAboutMenu);}}voidCMyDlg::OnPaint(){if(IsIconic()){CPaintDCdc(this);HCURSORCMyDlg::OnQueryDragIcon(){return(HCURSOR)m_hIcon;}voidCMyDlg::OnOK(){//TODO:Addextravalidationhere//CDialog::OnOK();UpdateData(true);inti,n;doubleh1,h2,h3,m,flag,X00[2][1],d01[2][1],d02[2][1],d03[2][1];//确定键的执行程序doubleX01[2][1],X02[2][1],X03[2][1];doubleF0,F1,F2,F3,e1,e2,em;doubleX[2][1];doublef0,f1,f2,f3;X00[0][0]=m_x01;//对初始搜索点进行赋值X00[1][0]=m_x02;d01[0][0]=1,d01[1][0]=0;//初始索索方向的确定d02[0][0]=0,d02[1][0]=1;i=1;do{F0=(X00[0][0]*X00[0][0]+2*X00[1][0]*X00[1][0]-4*X00[0][0]-2*X00[0][0]*X00[1][0]),f0=F0;/ /初始点函数值h1=(4*d01[0][0]+2*d01[0][0]*X00[1][0]+2*d01[1][0]*X00[0][0])/(2*d01[0][0]*d01[0][0]+//确定搜索方向4*d01[1][0]*d01[1][0]-4*d01[1][0]*d01[0][0]);X01[0][0]=X00[0][0]+h1*d01[0][0],X01[1][0]=X00[1][0]+h1*d01[1][0];F1=(X01[0][0]*X01[0][0]+2*X01[1][0]*X01[1][0]-4*X01[0][0]-2*X01[0][0]*X01[1][0]),f1=F1;/ /确定F的函数值h2=(4*d02[0][0]+2*d02[0][0]*X01[1][0]+2*d02[1][0]*X01[0][0])/(2*d02[0][0]*d02[0][0]+//确定搜索步长4*d02[1][0]*d02[1][0]-4*d02[1][0]*d02[0][0]);X02[0][0]=X01[0][0]+h2*d02[0][0];X02[1][0]=X01[1][0]+h2*d02[1][0];F2=(X02[0][0]*X02[0][0]+2*X02[1][0]*X02[1][0]-4*X02[0][0]-2*X02[0][0]*X02[1][0]),f2=F2;//确定F2的函数值e1=f0-f1;//进行判定e2=f1-f2;if(e1>e2)em=e1,m=1;elseem=e2,m=2;//////////////////////////////////////////////////////////////////////////////d03[0][0]=X02[0][0]-X00[0][0];d03[1][0]=X02[1][0]-X00[1][0];X03[0][0]=2*X02[0][0]-X00[0][0];X03[1][0]=2*X02[1][0]-X00[1][0];F3=(X03[0][0]*X03[0][0]+2*X03[1][0]*X03[1][0]-4*X03[0][0]-2*X03[0][0]*X03[1][0]),f3=F3;/ /确定F3的函数值while(F3>=F0&&(F0-2*F2+F3)*(F0-F2-em)*(F0-F2-em)>=*(F0-F3)*(F0-F3))//不满足判别条件{i++;if(F2<F3){X00[0][0]=X02[0][0],X00[1][0]=X02[1][0];//以函数最小者作为下轮迭代的始点F0=(X00[0][0]*X00[0][0]+2*X00[1][0]*X00[1][0]-4*X00[0][0]-2*X00[0][0]*X00[1][0]),f0=F0;//进行第二轮搜索h1=(4*d01[0][0]+2*d01[0][0]*X00[1][0]+2*d01[1][0]*X00[0][0])/(2*d01[0][0]*d01[0][0]+//确定步长4*d01[1][0]*d01[1][0]-4*d01[1][0]*d01[0][0]);X01[0][0]=X00[0][0]+h1*d01[0][0],X01[1][0]=X00[1][0]+h1*d01[1][0];F1=(X01[0][0]*X01[0][0]+2*X01[1][0]*X01[1][0]-4*X01[0][0]-2*X01[0][0]*X01[1][0]),f1=F1;//确定函数值h2=(4*d02[0][0]+2*d02[0][0]*X01[1][0]+2*d02[1][0]*X01[0][0])/(2*d02[0][0]*d02[0][0]+ //确定步长4*d02[1][0]*d02[1][0]-4*d02[1][0]*d02[0][0]);X02[0][0]=X01[0][0]+h2*d02[0][0];X02[1][0]=X01[1][0]+h2*d02[1][0];F2=(X02[0][0]*X02[0][0]+2*X02[1][0]*X02[1][0]-4*X02[0][0]-2*X02[0][0]*X02[1][0]),f2=F2; //确定函数值e1=f0-f1;e2=f1-f2;if(e1>e2)em=e1,m=1;//进行判断elseem=e2,m=2;d03[0][0]=X02[0][0]-X00[0][0];//确定新的搜索方向d03[1][0]=X02[1][0]-X00[1][0];X03[0][0]=2*X02[0][0]-X00[0][0];X03[1][0]=2*X02[1][0]-X00[1][0];F3=(X03[0][0]*X03[0][0]+2*X03[1][0]*X03[1][0]-4*X03[0][0]-2*X03[0][0]*X03[1][0]),f3=F3; //确定函数值}else{X00[0][0]=X03[0][0],X00[1][0]=X03[1][0];F0=(X00[0][0]*X00[0][0]+2*X00[1][0]*X00[1][0]-4*X00[0][0]-2*X00[0][0]*X00[1][0]),f0=F0; h1=(4*d01[0][0]+2*d01[0][0]*X00[1][0]+2*d01[1][0]*X00[0][0])/(2*d01[0][0]*d01[0][0]+ 4*d01[1][0]*d01[1][0]-4*d01[1][0]*d01[0][0]);X01[0][0]=X00[0][0]+h1*d01[0][0],X01[1][0]=X00[1][0]+h1*d01[1][0];F1=(X01[0][0]*X01[0][0]+2*X01[1][0]*X01[1][0]-4*X01[0][0]-2*X01[0][0]*X01[1][0]),f1=F1; h2=(4*d02[0][0]+2*d02[0][0]*X01[1][0]+2*d02[1][0]*X01[0][0])/(2*d02[0][0]*d02[0][0]+ 4*d02[1][0]*d02[1][0]-4*d02[1][0]*d02[0][0]);X02[0][0]=X01[0][0]+h2*d02[0][0];X02[1][0]=X01[1][0]+h2*d02[1][0];F2=(X02[0][0]*X02[0][0]+2*X02[1][0]*X02[1][0]-4*X02[0][0]-2*X02[0][0]*X02[1][0]),f2=F2;e1=f0-f1;e2=f1-f2;if(e1>e2)em=e1,m=1;elseem=e2,m=2;d03[0][0]=X02[0][0]-X00[0][0];d03[1][0]=X02[1][0]-X00[1][0];X03[0][0]=2*X02[0][0]-X00[0][0];X03[1][0]=2*X02[1][0]-X00[1][0];F3=(X03[0][0]*X03[0][0]+2*X03[1][0]*X03[1][0]-4*X03[0][0]-2*X03[0][0]*X03[1][0]),f3=F3;}}if(m=1)d01[0][0]=d03[0][0],d01[1][0]=d03[1][0];else{if(m=2)d02[0][0]=d03[0][0],d02[1][0]=d03[1][0];}h3=(4*d03[0][0]+2*d03[0][0]*X02[1][0]+2*d03[1][0]*X02[0][0])/(2*d03[0][0]*d03[0][0]+ 4*d03[1][0]*d03[1][0]-4*d03[1][0]*d03[0][0]);X00[0][0]=X02[0][0]+h3*d03[0][0];X00[1][0]=X02[1][0]+h3*d03[1][0];if(i=2)break;}while(abs(X02[0][0]-X00[0][0])>&&abs(X02[1][0]-X00[1][0])>;//输出极小值点X[0][0]=X00[0][0],X[1][0]=X00[1][0];m_x1=X[0][0];m_x2=X[1][0];UpdateData(false);}程序运行结果:四结论由该程序的运行结果可知,要求函数的极小值的在(10,5)处。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <malloc.h>
#include <conio.h>
#define n1 2
#define tt 0.005
#define ad 0.0000001
//定义常量
//tt初始迭代步长
//ad收敛精度
float ia;
float fny(float *x)
{
float f;
f=10*pow((x[0]+x[1]-5),2)+pow((x[0]-x[1]),2); //目标函数return(f);
}
float *iterate(float *x,float a, float *s)
{
float *x1;
x1=(float *)malloc(n1 * sizeof(float));
for (int i=0;i<n1;i++)
x1[i]=x[i]+a*s[i];
return(x1);
}
float func(float *x,float a,float *s)
{
float *x1;
x1=iterate(x,a,s);
float f=fny(x1);
return(f);
}
void finding(float a[3],float f[3],float *xk,float *s) {
float t=tt;
float a1,f1;
a[0]=0; f[0]=func(xk,a[0],s);
for (int i=0;;i++)
{
a[1]=a[0]+t; f[1]=func(xk,a[1],s);
if (f[1]<f[0])
break;
if (fabs(f[1]-f[0])>=ad)
{
t=-t;
a[0]=a[1]; f[0]=f[1];
}
else{
if (ia==1) return;
t=t/2; ia=1;
}
}
for (i=0;;i++)
{
a[2]=a[1]+t; f[2]=func(xk,a[2],s);
if (f[2]>f[1])
break;
t=2*t;
a[0]=a[1]; f[0]=f[1];
a[1]=a[2]; f[1]=f[2];
}
if (a[0]>a[2])
{
a1=a[0]; f1=f[0];
a[0]=a[2]; f[0]=f[2];
a[2]=a1; f[2]=f1;
}
return;
}
//second insert
float lagrange(float *xk,float *ft,float *s)
{
float a[3],f[3];
float b,c,d,aa;
finding (a,f,xk,s);
for (int i=0;;i++)
{
if (ia==1)
{
aa=a[1]; *ft=f[1];
break;
}
d=(pow(a[0],2)-pow(a[2],2))*(a[0]-a[1])-(pow(a[0],2)-pow(a[1],2))*(a[0]-a[2]);
if(fabs(d)==0)
break;
c=((f[0]-f[2])*(a[0]-a[1])-(f[0]-f[1])*(a[0]-a[2]))/d;
if(fabs(c)==0)
break;
b=((f[0]-f[1])-c*(pow(a[0],2)-pow(a[1],2)))/(a[0]-a[1]);
aa=-b/(2*c);
*ft=func(xk,aa,s);
if (fabs(aa-a[1])<=ad)
{
if (*ft>f[1]) aa=a[1];
break;
}
if (aa>a[1])
{
if (*ft>f[1])
{
a[2]=aa; f[2]=*ft;
}
else if (*ft<f[1])
{
a[0]=a[1]; a[1]=aa;
f[0]=f[1]; f[1]=*ft;
}
else if (*ft==f[1])
{
a[2]=aa; a[0]=a[1];
f[2]=*ft; f[0]=f[1];
a[1]=(a[0]+a[2])/2; f[1]=func(xk,a[1],s);
}
}
else
{
if (*ft>f[1])
{
a[0]=aa; f[0]=*ft;
}
else if (*ft<f[1])
{
a[2]=a[1]; a[1]=aa;
f[2]=f[1]; f[1]=*ft;
}
else if (*ft==f[1])
{
a[0]=aa; a[2]=a[1];
f[0]=*ft; f[2]=f[1];
a[1]=(a[0]+a[2])/2; f[1]=func(xk,a[1],s);
}
}
}
if (*ft>f[1])
{
aa=a[1]; *ft=f[1];
}
return (aa);
}
float *powell(float *xk)
{
float h[n1][n1],s[n1]={0,0},ff[n1+1]={0,0,0};
float f1,f3,aa;
float dk[n1],*x0,xk1[n1];
int m=0,i,j;
for (i=0;i<n1;i++)
{
for(j=0;j<n1;j++)
{
h[i][j]=0;
if (j==i)
h[i][j]=1;
}
}
for (int k=0;;k++)
{
ff[0]=fny(xk);
x0=xk;
for (i=0;i<n1;i++)
{
for (j=0;j<n1;j++)
s[j]=h[i][j];
float aa=lagrange(xk,&ff[i+1],s);
xk=iterate(xk,aa,s);
}
for (i=0;i<n1;i++)
{
float a,b;
dk[i]=xk[i]-x0[i];
xk1[i]=2*xk[i]-x0[i];
}
float max=fabs(ff[1]-ff[0]);
for (i=1;i<n1;i++)
if (fabs(ff[i+1]-ff[i])>max)
{
max=fabs(ff[i+1]-ff[i]);
m=i;
}
f3=fny(xk1);
if
((f3<ff[0])&&((ff[0]+f3-2*ff[2])*pow((ff[0]-ff[n1]-max),2)<0.5*max*pow((ff[0]-f3),2))) {
aa=lagrange(xk,&f1,dk);
xk=iterate(xk,aa,dk);
for (i=m;i<n1-1;i++)
for (j=0;j<n1;j++)
h[i][j]=h[i+1][j];
for (j=0;j<n1;j++)
h[n1-1][j]=dk[j];
}
else
{
if(ff[n1]>=f3) xk=xk1;
}
float xq=0;
for (i=0;i<n1;i++)
xq+=pow((xk[i]-x0[i]),2);
if (xq<=ad)
break;
}
return(xk);
}
void main()
{
float xk[n1]={0,0};//取初始点
float *xx;
xx=(float *)malloc(n1 *sizeof(float));
xx=powell(xk);
float ff=fny(xx);
cout<<"优化的结果为:"<<endl;
printf("\n\nThe Optimal Design Result Is:\n");
for (int i=0;i<n1;i++)
printf("\n\t x[%d] *=%f",i+1,xx[i]);
printf("\n\t f*=%f",ff);
getch();
}。