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

#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <math.h>

#define MaxRazm 3
int razm=2;

class VecT
{
  double x[MaxRazm];
  public:
   VecT(double *a=NULL,int n=0);
   VecT operator * (double k);
   VecT operator - (VecT& B);
   VecT operator + (VecT& B);
   void Print(void);
   void Invers(void);
   double GetXi(int i)
    {return x[i];}
   double Modul(void);
};
////////////////////////////////////////////////
VecT::VecT(double *a,int n)
{
  int i;
  for(i=0;i<razm && a;i++)
     {
	if(i<n)
	   x[i]=a[i];
	else x[i]=0;
     }
 }
////////////////////////////////////////////////
void VecT::Print(void)
{
  int i;
  printf("( ");
  for(i=0;i<razm;i++)
    {
      printf("%6.4f",x[i]);
      if(i!=razm-1)
         printf(" ; ");
    }
  printf(")");
}
////////////////////////////////////////////////
void VecT::Invers(void)
{
  int i;
  for(i=0;i<razm;i++)
     x[i]=-x[i];
}
////////////////////////////////////////////////
double VecT::Modul(void)
{
  int i;
  double modul=0;
  for (i=0;i<razm;i++)
  modul+=x[i]*x[i];
  return sqrt(modul);
}
////////////////////////////////////////////////
VecT VecT::operator + (VecT &B)
{
  VecT V;
  for(int i=0;i<razm;)
     V.x[i]=this->x[i]+B.x[i++];
  return(V);
}
////////////////////////////////////////////////
VecT VecT::operator - (VecT &B)
{
   VecT V;
   for(int i=0;i<razm;)
      V.x[i]=this->x[i]-B.x[i++];
   return(V);
}
////////////////////////////////////////////////
VecT VecT::operator * (double k)
{
   VecT V;
   for(int i=0;i<razm;i++)
      V.x[i]=this->x[i]*k;
   return(V);
}
////////////////////////////////////////////////
double F1(VecT V)
{
   return(100*pow(V.GetXi(1)-pow(V.GetXi(0),2),2)+pow(1-V.GetXi(0),2));
}
////////////////////////////////////////////////
double F2(VecT V)
{
   return(pow(V.GetXi(0)-1,2)+pow(V.GetXi(1)-3,2)+4*pow(V.GetXi(2)+5,2));
}
////////////////////////////////////////////////
double** Hes1(VecT V)
{
   double **H;
   H=new double*[razm];
   for(int i=0;i<razm;i++)
      H[i] = new double [razm];
   H[0][0]=1200*pow(V.GetXi(0),2)-400*V.GetXi(1)+2;
   H[0][1]=-400*V.GetXi(0);
   H[1][0]=-400*V.GetXi(0);
   H[1][1]=200;
   return H;
}
////////////////////////////////////////////////
double** Hes2(VecT V)
{
  double **H;
  H=new double*[razm];
  for(int i=0;i<razm;i++)
     H[i] = new double [razm];
  H[0][0]=2;
  H[0][1]=0;
  H[0][2]=0;
  H[1][0]=0;
  H[1][1]=2;
  H[1][2]=0;
  H[2][0]=0;
  H[2][1]=0;
  H[2][2]=8;
  return H;
}
////////////////////////////////////////////////
VecT X0[2];
double Ex;
int NumF=0;
double (*FUNC[2])(VecT)={F1,F2};
double** (*HES[2])(VecT)={Hes1,Hes2};
////////////////////////////////////////////////
double** Minor(double** A,int n,int i,int j)
{
  int k,s,l,m,r;
  double **min;
  min=new double*[n-1];
  for(k=0;k<n-1;k++)
     min[k]=new double[n-1];
  s=0;
  for(l=0;l<n;l++)
    {
      r=0;
      for(k=0;l!=i && k<n;k++)
	{
	  if(k!=j)
	     min[s][r++]=A[l][k];
	}
      if (l!=i)
         s++;
    }
   return min;
}
////////////////////////////////////////////////
double determin(double** A,int n)
{
  int i;
  double det=0,**minor;
  if(n>1)
    {
      for(i=0;i<n;i++)
         {
            minor=Minor(A,n,0,i);
            det+=pow(-1,i)*A[0][i]*determin(minor,n-1);
         }
      for(i=0;i<n-1;i++)
	 delete minor[i];
      delete minor;
      return det;
     }
   else
     return(**A);
}
////////////////////////////////////////////////
double** ObrMatr(double** H)
{
   double **ObrH,**A;
   int i,j;
   ObrH=new double*[razm];
   for(i=0;i<razm;i++)
      ObrH[i] = new double [razm];
   for(i=0;i<razm;i++)
      for(j=0;j<razm;j++)
	ObrH[i][j]=pow(-1,i+j)*determin(Minor(H,razm,j,i),razm-1)/determin(H,razm);
   for(i=0;i<razm;i++)
      delete H[i];
   delete H;
   return ObrH;
}
////////////////////////////////////////////////
VecT NumDif(VecT A)
{
   VecT V,*Ort;
   double d=0.0000001,*df,*t;
   int i;
   t = new double[razm];
   df = new double[razm];
   for(i=0;i<razm;)
      t[i++]=0;
   Ort = new VecT[razm];
   for(i=0;i<razm;i++)
     {
	t[i]=1;
	Ort[i]=VecT(t,razm);
	df[i] = (FUNC[NumF](A+Ort[i]*d)-FUNC[NumF](A))/d;
	t[i]=0;
     }
   V=VecT(df,razm);
   delete t;
   delete df;
   delete Ort;
   return V;
}
////////////////////////////////////////////////
VecT MatrPro(double** rHk,VecT V)
{
  double temp[MaxRazm];
  int i,j;
  VecT C;
  for(i=0;i<razm;i++)
    {
	temp[i]=0;
	for(j=0;j<razm;j++)
	   temp[i]+=rHk[i][j]*V.GetXi(j);
    }
  C=VecT(temp,razm);
  return C;
}
////////////////////////////////////////////////
void Newton(void)
{
  double **Hk,**rHk,Bk=0,prod=0;
  int k=0,MaxIt=1000,i;
  VecT pk,Grk,xk,xk2;
  xk=X0[NumF];
  Grk=NumDif(xk);
  while(Grk.Modul()>Ex && k<MaxIt  || prod>0 )
    {
	prod=0;
	Hk=HES[NumF](xk);
	Grk=NumDif(xk);
	for(i=0;i<razm;i++)
	    Hk[i][i]+=Bk;
	rHk=ObrMatr(Hk);
	pk=MatrPro(rHk,Grk);
   	xk2=xk-pk;
    //	xk2.Print();
    //	pk.Print();//getch();
    //	printf("\n");
	Grk=NumDif(xk);
	for(i=0;i<razm;i++)
	   prod+=Grk.GetXi(i)*(-pk.GetXi(i));
	if(prod<0)
 	  {
	    Bk/=2;
	    xk=xk2;
	    k++;
	  }
	else
	   Bk*=2;
	for(i=0;i<razm;i++)
	   delete rHk[i];
	delete rHk;
 }
 printf("\nЉ®«ЁзҐбвў® ЁвҐа жЁ©=%d  ’®зЄ  ¬Ё­Ё¬г¬ : ",k);
 xk.Print();
}
///////////////////////////////////////////////////
void main(void)
 {
    clrscr();
    NumF=0;
    razm=2;
    double t[]={-1.2,1,0};
    X0[0]= VecT (t,2);
    t[0]=4;t[1]=-1;t[2]=2;
    X0[1]= VecT (t,3);
    Ex=0.01;
    printf("ЋЎ®ЎйҐ­­л© ¬Ґв®¤ Ќмов®­ :");printf("\n");
    printf("€б室­лҐ ¤ ­­лҐ:");printf("\n");
    printf("‘в ав®ў п в®зЄ :");
    X0[NumF].Print();printf("\n");
    printf("’®з­®бвм:%8.5f",Ex);printf("\n");
    printf("ЋвўҐв:");printf("\n\n");
    if(NumF==1)Ex=0.01;
    Newton();
    getch();
 }