Лабораторная работа 10 / LR_10 v / LR10_1

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

int n=10;
float h=0.187;

void main()
   {
      clrscr();
      cout<<"\n                         Welcome!\n";
      cout<<"Programm calculation y = f(x)\n";
      printf("\nInput n = ");
      scanf("%d",&n);
//      n--;
      void mas_init(float*,float*);
      double Count(float,float*,float*);
      float *X,*F;
      X = new float[n+1];
      F = new float[n+1];
      double Ln1, Ln2, Ln3, Ln4, Ln;

      float  x1=1.3020,
	     x2=1.5690,
	     x3=1.8350;

      mas_init(X,F);
      printf("\n");
      printf("x1=");
      scanf("%f",&x1);
      printf("x2=");
      scanf("%f",&x2);
      printf("x3=");
      scanf("%f",&x3);
      Ln1=Count(x1,X,F);
      printf("Ln(x1) = %f\n",Ln1);
      Ln2=Count(x2,X,F);
      printf("Ln(x2) = %f\n",Ln2);
      Ln3=Count(x3,X,F);
      printf("Ln(x3) = %f\n",Ln3);
cout<<"\nPress any key to exit, please.\n";
      getch();
      delete(X);
      delete(F);
   }

void mas_init(float* X, float* F)
   {
      cout<<"\nHow do you want to read massiv?";
      cout<<"\n\t1. Standart";
      cout<<"\n\t2. From file";
      cout<<"\n\t3. Write by yourself";
      cout<<"\n\t4. Exit\n";
      int m;
      do
	 {
	  cin>>m;
	 }
      while ((m!=1)&(m!=2)&(m!=3)&(m!=4));
      switch (m)
	 {
	  case 1:
	     {
		if(n!=10) goto must_do;
		X[0] = 0.3120; F[0] = -0.3060;
		X[1] = 0.4990; F[1] = -0.0760;
		X[2] = 0.6870; F[2] =  0.0180;
		X[3] = 0.8740; F[3] =  0.0150;
		X[4] = 1.0620; F[4] = -0.0440;
		X[5] = 1.2490; F[5] = -0.1210;
		X[6] = 1.4370; F[6] = -0.1770;
		X[7] = 1.6240; F[7] = -0.1720;
		X[8] = 1.8120; F[8] = -0.0650;
		X[9] = 1.9990; F[9] =  0.1800;
		X[10] =2.1870; F[10] = 0.6080;
		break;
	     }

 /*	  case 2:
	     {
		FILE *file;
		char *file_name;
		printf("\nInput file_name, please:  ");
		scanf("%s",file_name);
		file = fopen(file_name,"r");
		if (file == 0)
		   {
		      perror("\nFile not open.");
		      exit(1);
		   }
		else
		   {
		      char c,strX="", strF="",strXdop="",strFdop="";
		      for (int i=0; i<=n+1; i++)
			{
			   while (c = fgets(file) != #13 ) strcat(strXdop,c);
			   strX=strXdop;
			   while(c=fgets(file) != "\n") strcat(strXdop,c);
			   while (c = fgets(file) != #13 ) strcat(strFdop,c);
			   strF=strFdop;
			   while(c=fgets(file) != "\n") strcat(strFdop,c);
			   X[i]=atof(const strX);
			   F[i]=atof(const strF);

			 }
		   }
		fclose(file);
	     }

 */	  case 3:
	     {
		must_do:
		printf("Please input the X[i] in growing order:\n");
		for(int i=0;i<=n;i++)
		   {
		      printf("X[%d] = ",i);
		      scanf("%f",&X[i]);
		      printf("F[%d] = ",i);
		      scanf("%f",&F[i]);
		   };
		break;
	     }

	  case 4:
	     {
	       cout<<"\nYou wanted to exit!\n";
	       cout<<"Good buy.\n";
	       default:
	       exit(0);
	     }
	 }
      h=X[1]-X[0];
   }


/*void mas_init(float* X, float* F)
   {
      char ans;
      printf("\nRead standart? ");
      ans = getche();
      printf("\n");
      if(ans!='Y' && ans!='y')
	 {
	    must_do:
	    printf("Please input the X[i] in growing order:\n");
	    for(int i=0;i<=n;i++)
	       {
		  printf("X[%d] = ",i);
		  scanf("%f",&X[i]);
		  printf("F[%d] = ",i);
		  scanf("%f",&F[i]);
	       };
	 }
      else
	 {
	    if(n!=10) goto must_do;
	    X[0] = 0.3120; F[0] = -0.3060;
	    X[1] = 0.4990; F[1] = -0.0760;
	    X[2] = 0.6870; F[2] =  0.0180;
	    X[3] = 0.8740; F[3] =  0.0150;
	    X[4] = 1.0620; F[4] = -0.0440;
	    X[5] = 1.2490; F[5] = -0.1210;
	    X[6] = 1.4370; F[6] = -0.1770;
	    X[7] = 1.6240; F[7] = -0.1720;
	    X[8] = 1.8120; F[8] = -0.0650;
	    X[9] = 1.9990; F[9] =  0.1800;
	    X[10] =2.1870; F[10] = 0.6080;
	 };
      h=X[1]-X[0];
   }
*/
/**************************************************************/

int fact(int i)
   {
      if (i<=1) return 1;
      else return (i*fact(i-1));
   }

/**************************************************************/

int C(int j, int k)
   {
      return (fact(k)/(fact(j)*fact(k-j)));
   }

/**************************************************************/

double down_dif_St(int r, int k, int num, float* F, int indic)
   {
      double sum=0;

      for(int j=0; j<=r; j++)
	 if(!indic) sum+=pow(-1,j)*C(j,r)*F[k+r-j+num];
	 else sum+=pow(-1,j)*C(j,r)*F[-k-r+j+num];
      return (sum);
   }

/**************************************************************/

double down_dif(int r, int k, float* F)
   {
      double sum=0;

      for(int j=0; j<=r; j++)
	 sum+=pow(-1,j)*C(j,r)*F[k+r-j];
      return (sum);
   }

/**************************************************************/

double up_dif(int r, int k, float* F)
   {
      return (down_dif(r,k-r,F));
   }

/**************************************************************/

double back_Newton(float x, float* X, float* F)
   {
      double sum=F[n], q, a;

      q=(x-X[n])/h;
      a=q;
      for(int i=1; i<=n; i++, a*=(q+i-1))
	 sum+=a*up_dif(i,n,F)/fact(i);
      return (sum);
   }

/**************************************************************/

double forw_Newton(float x, float* X, float* F)
   {
      double sum=F[0], q, a;

      q=(x-X[0])/h;
      a=q;
      for(int i=1; i<=n; i++, a*=(q-i+1))
	 sum+=a*down_dif(i,0,F)/fact(i);
      return (sum);
}

/**************************************************************/

double Stirling(float x, int num, float* X, float* F)
   {
      double sum, q, a;
      int indic=0;

      q=(x-X[num])/h;
      if(q<0) indic=1;
      sum=F[num];
      a=1;
      for(int i=1; i<=(n-num); i++, a*=(q*q-(i-1)*(i-1)) )
	 sum+=q*a*(down_dif_St(2*i-1,-i,num,F,indic)+down_dif_St(2*i-1,-i+1,num,F,indic))/(fact(2*i-1)*2)+q*q*a*down_dif_St(2*i,-i,num,F,indic)/fact(2*i);
      return (sum);
   }

/**************************************************************/

double Count(float x0, float* X, float* F)
   {
      for(int i=0; i<=n && x0>X[i];i++);
      if(((i>=((n+1)/4))&(i<=((3*n+3)/4))
      &&(((X[i]-x0)/h)<=0.25)|(((x0-X[i-1])/h)<=0.25)))
	 {
	    cout<<"\nThe method of Stirling is optimum:\n\t";
	    int num=i;
	    if(((X[i]-x0)/h)>0.25) num=i-1;
	    return Stirling(x0,num,X,F);

	 }
      else
	 {
	    if(i>(n+1)/2)
	       {
		  cout<<"\nThe method of Back Newton is optimum:\n\t";
		  return back_Newton(x0,X,F);
	       }
	    else
	       {
		  cout<<"\nThe method of Forward Newton is optimum:\n\t";
		  return forw_Newton(x0,X,F);
	       }

	 }
   };