Различные алгоритмы минимизации, реализованные в С++ / all / Hook_Swan4_HOOK-JIVS_Partan

#include <iostream.h>
#include <conio.h>
#include <math.h>


//--------------------------Vector3D---------------------------------
 class Vector3D {
 public:
	float x1;
	float x2;
	float x3;
	Vector3D (float=0,float=0,float=0);
	~Vector3D() {}


	Vector3D& SetVect(float a,float b,float c) { x1=a; x2=b; x3=c; return *this; }
	void print() const;
	float norm();
	//--------------операци --------------------
	Vector3D  operator -(const Vector3D &);
	Vector3D&  operator +(const Vector3D &);
	float      operator *(const Vector3D &);
 };


	Vector3D::Vector3D(float a ,float b,float c)
	 { x1=a;  x2=b;   x3=c; }
	void Vector3D:: print() const { cout<<"("<<x1<<","<<x2<<","<<x3<<")"<<endl; }

	Vector3D Vector3D:: operator -(const Vector3D &M)
	{
		 Vector3D vsp;
	vsp.x1=x1-M.x1;
	vsp.x2=x2-M.x2;
	vsp.x3=x3-M.x3;

	return vsp;
	}

	Vector3D& Vector3D:: operator +(const Vector3D &N)
	{
	 x1+=N.x1;
	 x2+=N.x2;
	 x3+=N.x3;
	 return *this;
	}

	float Vector3D::   operator *(const Vector3D &N){
	return x1*N.x1+x2*N.x2+x3*N.x3;
	}

	float Vector3D:: norm()
 {
	 return sqrt(x1*x1+x2*x2+x3*x3);
 }

	float f(Vector3D a)
 { return 3*(a.x1-4)*(a.x1-4)+5*(a.x2+3)*(a.x2+3)+7*(2*a.x3+1)*(2*a.x3+1);}

	float dfx1(Vector3D b)
	{ return (6*b.x1-24); }

	float dfx2(Vector3D c)
	{ return (10*c.x2+30);}

	float dfx3(Vector3D c)
	{ return (28*c.x3+14);}

	Vector3D  DIFR( Vector3D x0)
	{
		double deltaY1,deltaY2,deltaY3;
		Vector3D tmp;
		double deltaX1,deltaX2,deltaX3;
		deltaX1=0.0001*x0.x1;
		deltaX2=0.0001*x0.x2;
		deltaX3=0.0001*x0.x3;

		tmp=x0;

		tmp.x1+=deltaX1;
		deltaY1=(f(tmp)-f(x0))/deltaX1;


		tmp=x0;
		tmp.x2+=deltaX2;
		deltaY2=(f(tmp)-f(x0))/deltaX2;

		tmp=x0;
		tmp.x3+=deltaX3;
		deltaY3=(f(tmp)-f(x0))/deltaX3;
		Vector3D grad(deltaY1,deltaY2,deltaY3);

		return  grad;
}

	void xtoalfa(Vector3D x,Vector3D p,Vector3D x0,float &alf)
	{

	 if(p.x1==0)
		 if(p.x2==0)
			if(p.x3==0)
	 alf=0;
			 else
	 alf=(x.x3-x0.x3)/p.x3;
		 else
			alf=(x.x2-x0.x2)/p.x2;
		else
		 alf=(x.x1-x0.x1)/p.x1;
	}

	void alfatox(Vector3D &x,Vector3D p,Vector3D x0,float alf)
	{
		x.x1=x0.x1+alf*p.x1;
		x.x2=x0.x2+alf*p.x2;
		x.x3=x0.x3+alf*p.x3;
	}

 float dfp(Vector3D x,Vector3D p)
	{

		//Vector3D grad(dfx1(x),dfx2(x),dfx3(x));
		//return grad*p;
		 return DIFR(x)*p;
	}

//---------------SVENN-4----------------------
void SV4(Vector3D &a, Vector3D &b,float &alfa1,float &alfa2, Vector3D &p, Vector3D x0)
{
 float sumofalfa=0;
 float alfa;
 Vector3D x,xpred;

 //cout<<"‚ўҐ¤ЁвҐ ЇҐаў®­ з «м­л© и Ј alf1\n";
 //cin>>alfa;
 alfa=0.001;

 if(dfp(x0,p)>0)
   {
     p.x1=-p.x1;
     p.x2=-p.x2;
     p.x3=-p.x3;
   }

 x=xpred=x0;
 float dfpx0=dfp(x0,p);
 alfatox(x,p,x0,alfa);
 int count=0;
 sumofalfa+=alfa;
 for(;;)
 {
   count++;

   if( (dfpx0*dfp(x,p))<0 )
   break;

   alfa=2*alfa;
   sumofalfa+=alfa;
   xpred=x;
   alfatox(x,p,x0,sumofalfa);
 }

  a=xpred;
  b=x;

 a.print();
 b.print();

 xtoalfa(a,p,x0,alfa1);
 xtoalfa(b,p,x0,alfa2);

 cout<<"interval--->"<< alfa1<<"--"<<alfa2<<"\n"<<"  count= "<<count<<"\n";
 cout<<"f(a)  "<<f(a)<<endl;
 cout<<"f(b)  "<<f(b)<<endl;
 cout<<"dfp(a)  "<<dfp(a,p)<<endl;
 cout<<"dfp(b)  "<<dfp(b,p)<<endl;
}


//--------Dixotomia------------------------------
void DAV(float al1, float al2 ,Vector3D p, Vector3D x0,float e,Vector3D &MIN)
{
 float min;
 float m,n;
 float f1,f2;
 Vector3D xtemp;
 const float d=0.00001;
 while( (fabs(al1-al2)) > e)
	{
	m=(al1+al2-d)/2;
	alfatox(xtemp,p,x0,m);
	 f1=f(xtemp);
	n=(al1+al2+d)/2;
	alfatox(xtemp,p,x0,n);
	 f2=f(xtemp);

	if(f1<f2)
		al2=n;
	else
		al1=m;

 cout<<"al1= "<<al1<<"   "<<"al2= "<<al2<<endl;
 cout<<"fabs--->>"<<fabs(al1-al2)<<endl;

}

 min=float((al1+al2)/2);

cout<<"Result is ----->> "<<min;
alfatox(MIN,p,x0,min);
MIN.print();
getch();
}
//------------HOOK-JIVS------------------------
void HOOK(Vector3D baza,float e)
{
 Vector3D p1(1,0,0),p2(0,1,0),p3(0,0,1);
 Vector3D x1;
 Vector3D a,b,c,res,d;
 float al1,al2;
 int count=0;
 x1=baza;


 while(getch()!=27)
 {
	 count++;

	 cout<<"HOOKITER="<<count<<endl;

	 cout<<" direction p1 "<<endl;
	 SV4(a,b,al1,al2,p1,x1);
	 DAV(al1,al2,p1,x1,e,res);

	 cout<<" direction p2 "<<endl;
	 SV4(a,b,al1,al2,p2,res);
	 DAV(al1,al2,p2,res,e,res); //!!!!!! change dix to dav

	 cout<<" direction p3 "<<endl;
	 SV4(a,b,al1,al2,p3,res);
	 DAV(al1,al2,p3,res,e,res);
	 cout<<" result after 3p---> ";
	 res.print();
	 cout<<"baza = ";
	 baza.print();

	 d=res-baza;

	 d.print();

	 cout<<"||d||==> "<<d.norm()<<endl;

	 if( d.norm()<=e )
	 break;


	 baza=res;


	 SV4(a,b,al1,al2,d,res);

	 DAV(al1,al2,d,res,e,res);

	 x1=res;

 }

cout<<"min---> ";
res.print();
}


void Partan(Vector3D x0, float e)
{
	Vector3D a,b,c,d,res,x1,x2,x3,x4;
	float al1,al2;
	int count=0;
	x1=x0;

	Vector3D p1(-dfx1(x0),-dfx2(x0),-dfx3(x0));

	//antigrad step  x1---->x2
	SV4(a,b,al1,al2,p1,x1);
		DAV(al1,al2,p1,x1,e,res);
	x2=res;// save the x2

	while(1)
	{
		count++;

	cout<<"PortanITER----> "<<count<<endl;

	Vector3D p2(-dfx1(x2),-dfx2(x2),-dfx3(x2));

	//antigrad step  x2----->x3
	SV4(a,b,al1,al2,p2,x2);
		DAV(al1,al2,p2,x2,e,res);
	x3=res; // save the x3


	d=x3-x1;

	if(d.norm()<=e)
	break;

		//speedy step to x4
	SV4(a,b,al1,al2,d,x3);
		DAV(al1,al2,d,x3,e,res);
	x4=res;  //save x4

	//preparation for next iteration
	x1=x2;
	x2=x4;

	}

cout<<"min---> ";
res.print();
}

void main()
{
	const float e=0.001;
	Vector3D x0(2,-2,-2);
	HOOK(x0,e);
}