鲍威尔法.cpp

优化设计一维搜索方法的黄金分割法

#include<iostream.h>
#include<math.h>
float  X[2], X0[2],  X1[2], X2[2], X3[2], a=0;
float S1[2]={1,0}, S2[2]={0,1}, S3;
int flag=0;
float G=0, G0=0, G2=0, G3=0;
float M[2];
float Cons, M1 ,M2, m;
float Original(float a[2])            ////////////// 原函数
{
   float f;
   f=10*pow((a[0]+a[1]-5),2)+pow((a[0]-a[1]),2);
   return f;
}
float Dervative(float a[2], float b[2])     //////////////////////////////////求导数
{
  float f;
  if((b[0]+b[1])<0)
  { 
    if((b[0]-b[1])<0)    ///////////        情况1    
	{
	  f=(-100+22*a[0]+18*a[1])/(-22*b[0]-18*b[1]);
	}
	else 
	{
	  f=(-100+18*a[0]+22*a[1])/(-18*b[0]-22*b[1]);
	}                    /////////          情况2 
  }
  else
  {
    if((b[0]-b[1])<1)    /////////          情况3 
	{
	  f=(100-18*a[0]-22*a[1])/(18*b[0]+22*b[1]);  
	}
    else                ///////////////////      情况4
	{
	   f=(100-22*a[0]-18*a[1])/(22*b[0]+18*b[1]);  
	}
  }
  return f;
}
void FX3(float a[2],float b[2],float c[2])  /////  2*X2-X1
{
  c[0]=2*b[0]-a[0];
  c[1]=2*b[1]-a[1];
}
void  Search(float a[2], float b[2], float c[2], float f)  ///  一维搜索函数
{
  c[0]=a[0]+f*b[0];
  c[1]=a[1]+f*b[1];
} 

int Compar(float a, float b)   /////////////////////比较函数
{
 if(a>b) return 1;
 else  return 0;
}
float Dap(float a[2], float b[2]) ////////////////终止程序函数
{
 float f;
 f= sqrt(pow((a[0]+b[0]),2)+pow((a[1]+b[1]),2));
 return f;
}
void Transition(float a[2], float b[2],float c[2])  ////////转换
{
  c[0]=a[0]-b[0];
  c[1]=a[1]-b[1];
}
void Init()
{
 cout<<"请输入初始点" <<endl;
 cin>>X0[0]>>X0[1]; /////////////////输入起始函数
 cout<<"请输入收敛精度"<<endl;
 cin>>Cons;

}
int  Condition(float a, float b, float c,float d)
{
   if((a-2*b+c)*pow( (a-b-d),2) < 0.5*d*pow( (a-c),2 ) && c<a ) return 1;
   else return 0;
}
void Chang(float c[2],float d[2])
{
  c[0]=d[0];
  c[1]=d[1];
}
void Cyc()   ///////////////////////函数循环
{
    a=Dervative(X0, S1);                                  
    Search(X0, S1, X1, a);      
//    M1=G0-Original[X1];	  /////////第一次
    a=Dervative(X1, S2); 
	Search(X1, S2, X2, a); 
//	G2=Original[X2];
//	M2=Original[X1]-Original[X2];////////////第二次收索
	flag=Compar(M1,M2);
	if(flag)
	{
      m=M1;
	}
    else
	{
	  m=M2;
	}
   FX3(X0,X2,X3);
//   G3=Original[X3];
}
void main(void)
{
  Init();
   G0=Original[X0];      //////////////////////////////////////////
  do
  {  
   

   Cyc();

   if( Condition(G0, G2, G3,m))
   {
//     Transition( X2, X0,S3);  //////////////////////////
 //    a=Dervative(X2, S3);
     Search(X, X2, X3, a);
 //    G=Original[X];
   }
   else 
    if(G2<G3)
	{
	  Chang(X0,X2);

	}
	else
	{
	 Chang(X0,X3);	
	}
  a=Dap(X, X0);
  if(a<Cons)
  break;

  }while(1);

  cout<<"完成"<<X[0]<<endl<<X[1]<<endl<<G<<endl;
}