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

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

class vector
{
 public:
 double x1;
 double x2;

   vector(double x,double y)
   {x1=x; x2=y;}
   vector()
   {x1=0; x2=0;}

   friend double  k1(vector& v) {return v.x1;}
   friend double  k2(vector& v) {return v.x2;}


   friend double al(vector x,vector p);
   friend double norm(vector& v);

   friend double  f(vector v);
   friend vector gradf(vector x);

   friend vector operator+ (vector a,vector b);
   friend vector operator- (vector a,vector b);
   friend vector operator* (double k,vector a);
   friend double operator * (vector a,vector b);
   friend vector operator/ (vector a,double k);

};

// ЋЇаҐ¤Ґ«Ґ­ЁҐ дг­ЄжЁ© ЇҐаҐЈаг§ЄЁ

  vector operator+ (vector a,vector b)
  { return vector((a.x1+b.x1),(a.x2+b.x2));}

  vector operator- (vector a,vector b)
  { return vector((a.x1-b.x1),(a.x2-b.x2));}

  vector operator* (double k, vector v)
  { return vector((k*v.x1),(k*v.x2));}

  ostream& operator<<(ostream&s,vector v)
  { return s <<"["<<k1(v)<<", "<<k2(v)<<"] \n";}

  double operator * (vector a,vector b)
  {
   double c=a.x1*b.x1+a.x2*b.x2;
   return c;
  }

  vector operator/ (vector a,double k)
  {return vector((a.x1/k),(a.x2/k));}


//§ ¤ ­­ п дг­ЄжЁп
 double f(vector x)
 {
 return ((1.5-x.x1*(1-x.x2))*(1.5-x.x1*(1-x.x2))+(2.25-x.x1*(1-x.x2*x.x2))*(2.25-x.x1*(1-x.x2*x.x2))+(2.625-x.x1*(1-x.x2*x.x2*x.x2))*(2.625-x.x1*(1-x.x2*x.x2*x.x2)));
//  return (x.x1*x.x1*x.x1+x.x2*x.x2-3*x.x1-2*x.x2+2);
 }

//Ја ¤ЁҐ­в дг­ЄжЁЁ
vector gradf(vector x)
{
 vector g;
   g.x1=2*(x.x2-1)*(1.5-x.x1*(1-x.x2))+2*(x.x2*x.x2-1)*(2.25-x.x1*(1-x.x2*x.x2))+2*(x.x2*x.x2*x.x2-1)*(2.625-x.x1*(1-x.x2*x.x2*x.x2));
//   g.x1=3*x.x1*x.x1-3;
   g.x2=2*x.x1*(1.5-x.x1*(1-x.x2))+4*x.x1*x.x2*(2.25-x.x1*(1-x.x2*x.x2))+6*x.x1*x.x2*x.x2*(2.625-x.x1*(1-x.x2*x.x2*x.x2));
//   g.x2=2*x.x2-2;
 return g;
}

//Їа®Ё§ў®¤­ п дг­ЄжЁЁ
double df(vector x,vector p)
{
 return (gradf(x)*p);
}


 double  norm (vector& v)
	   {
	    return sqrt(v.x1*v.x1+v.x2*v.x2);
	   }

 vector Davidon(vector x,vector p)
 {  double al,al1,al2;
    double n=fabs((f(x)-df(x,p))/df(x,p));
    if(n>1) {al=1;}
    else {al=n;}
    vector x0=x;
    vector p0=p;
    vector xx;
    int t;

     if (df(x0,p)>0)
      {
      p=(-1)*p;
      }
      double ddf=df(x0,p0);
     while(ddf*df(x,p0)>=0)
      {
	 if (df(x,p)!=0)
	 {
	 x=x+al*p;
	 al=2*al;
	 p=p0;
	 }
	 else
	  {
	  xx=x;
	  return (xx);
	  }
	  t++;
      }
      if (t==1) {al1=0;   al2=al/2;}
      else  { al1=al/4;   al2=al/2;}

      x0=x-al2*p0;
      vector x1=x;
      double w,z;
      while (fabs(df(x,p0))>=1e-5)
       {
	 z=df(x0,p0)+df(x1,p0)+3*(f(x0)-f(x1))/norm(x1);
	 w=sqrt(z*z-df(x0,p0)*df(x1,p0));

	 al=al2*((w+z-df(x0,p0))/(w-df(x0,p0)+df(x1,p0)));
	 x=x0+al*p0;


	 if (df(x,p0)<0)
	  {x0=x0+al*p0;}
	 else
	  {x1=x0+al*p0;al2=al;}
       }
	xx=x;

return (xx);

 }

 vector DFP(vector x1,vector x2,vector p)
 {  vector gamma,S,A1(1,0),A2(0,1),dx;
       gamma=gradf(x2)-gradf(x1);
       S.x1=A1*gamma;
       S.x2=A2*gamma;
       dx=x2-x1;
       double d=dx*gamma;
       A1=A1+(dx.x1*dx)/d-(S.x1*S)/(S*gamma);
       A2=A2+(dx.x2*dx)/d-(S.x2*S)/(S*gamma);
       p.x1=(-1)*gradf(x2)*A1;
       p.x2=(-1)*gradf(x2)*A2;
    return p;
  }

 vector BFSH(vector x1,vector x2,vector p)
 {  vector gamma,A1(1,0),A2(0,1),dx,B1,B2,BAB1,BAB2,E1(1,0),E2(0,1);
       gamma=gradf(x2)-gradf(x1);
       dx=x2-x1;
       double d=dx*gamma;
       B1=E1-dx.x1*gamma/d;
       B2=E2-dx.x2*gamma/d;
       BAB1.x1=(B1.x1*A1.x1+B1.x2*A2.x1)*B1.x1+(B1.x1*A1.x2+B1.x2*A2.x2)*B2.x1;
       BAB1.x2=(B1.x1*A1.x1+B1.x2*A2.x1)*B1.x2+(B1.x1*A1.x2+B1.x2*A2.x2)*B2.x2;
       BAB2.x1=(B2.x1*A1.x1+B2.x2*A2.x1)*B1.x1+(B2.x1*A1.x2+B2.x2*A2.x2)*B2.x1;
       BAB2.x2=(B2.x1*A1.x1+B2.x2*A2.x1)*B1.x2+(B2.x1*A1.x2+B2.x2*A2.x2)*B2.x2;
       A1=BAB1+(dx.x1*dx)/d;
       A2=BAB2+(dx.x2*dx)/d;
       p.x1=(-1)*gradf(x2)*A1;
       p.x2=(-1)*gradf(x2)*A2;
    return p;
  }

 vector BFGSH(vector x1,vector x2,vector p)
 {  vector gamma,S,A1(1,0),A2(0,1),dx;
       gamma=gradf(x2)-gradf(x1);
       S.x1=A1*gamma;
       S.x2=A2*gamma;
       dx=x2-x1;
       double d=dx*gamma;
       A1=A1+(1+(S*gamma)/d)*(dx.x1*dx)/d-(dx.x1*S+S.x1*dx)/d;
       A2=A2+(1+(S*gamma)/d)*(dx.x2*dx)/d-(S.x2*dx+dx.x2*S)/d;
       p.x1=(-1)*gradf(x2)*A1;
       p.x2=(-1)*gradf(x2)*A2;
    return p;
  }

 vector MakKormik(vector x1,vector x2,vector p)
 {  vector gamma,S,A1(1,0),A2(0,1),dx;
       gamma=gradf(x2)-gradf(x1);
       S.x1=A1*gamma;
       S.x2=A2*gamma;
       dx=x2-x1;
       double d=dx*gamma;
       A1=A1+(dx.x1*dx)/d-(S.x1*dx)/d;
       A2=A2+(dx.x2*dx)/d-(S.x2*dx)/d;
       p.x1=(-1)*gradf(x2)*A1;
       p.x2=(-1)*gradf(x2)*A2;
    return p;
    }

 vector Daniel(vector x1,vector x2,vector p)
 {    double beta;
      beta=(gradf(x2)*(gradf(x2)-gradf(x1)))/(p*(gradf(x2)-gradf(x1)));
      p=(-1)*gradf(x2)+beta*p;
   return p;
  }

 vector PR(vector x1,vector x2,vector p)
 {    double beta;
      beta=(gradf(x2)*(gradf(x2)-gradf(x1)))/(gradf(x1)*gradf(x1));
      p=(-1)*gradf(x2)+beta*p;
   return p;
      }

 vector FR(vector x1,vector x2,vector p)
 {    double beta;
      beta=(norm(gradf(x2))*norm(gradf(x2)))/(norm(gradf(x1))*norm(gradf(x1)));
      p=(-1)*gradf(x2)+beta*p;
   return p;
  }


 void main()
{   clrscr();
    div_t t;
    double eps=1e-4;
    int k=1;
    vector x0(0,0),x1,x2,p(0,0);
      x2=x1=x0;
      do
      {
      t=div(k,2);
      if(t.rem==1)  {p=(-1)*gradf(x2);}
      else
      {
       p=PR(x1,x2,p);
      // p=FR(x1,x2,p);
      // p=Daniel(x1,x2,p);
      // p=DFP(x1,x2,p);
      // p=BFSH(x1,x2,p);
      // p=BFGSH(x1,x2,p);
      // p=MakKormik(x1,x2,p);
      }
      x1=x2;
      x2=Davidon(x1,p);
      k++;
      }
      while (norm(gradf(x2))>=eps || gradf(x1)*gradf(x2)>=0.2*norm(gradf(x2)));
      cout<<"ЂЇЇа®ЄбЁ¬ЁагойЁ© ¬Ё­Ё¬г¬ е = "<<x2<<endl;
      cout<<"Љ®«ЁзҐбвў® ЁвҐа жЁ© = "<<k-1<<endl;
      getch();

   while(!kbhit());

}