Помогите, из метода обратной матрицы в метод Гаусса

[Storgnit]

Вот текст программы нужно ,чтобы вычисления вектора С было с помощью метода Гаусса

#include<stdio.h>
#include<conio.h>
#include<math.h>
#define n 5
#define m 3

//функция Fl(k,x[i]) //
float FL(int k, float x)
{ 
float Fl;
    if (k==0) Fl=1;
    else 
    {
	 if (k==1) Fl=x;
  	 else Fl=exp(2*x);
    }
return Fl;
}

//ввод исходных данных
void vvod_koord(float x[n], float y[n])
{
    int i;
	for (i=0;i<n;i++)
	 {
	 printf("vvedite x,y[%i]  ",i+1);
	 scanf("%f%f",&x[i],&y[i]);
     }
}

//вычисляем коэффициенты A //
void massiv_A(float A[m][m],float x[n])
{
	int k,l,i;
	float Flk,Fll;
	for (k=0;k<m;k++)
	for (l=0;l<m;l++)
		{
		A[k][l]=0;
		for (i=0;i<n;i++)
		  {
		  Flk=FL(k,x[i]);
		  Fll=FL(l,x[i]);
		  A[k][l]=A[k][l]+(Flk*Fll);
		  }
		}
}

//вычисляем коэффициенты в //
void massiv_B(float B[m], float x[n], float y[n])
{
	 int k,i;
	 for (k=0;k<m;k++)
	  {
	 	B[k]=0;
		for (i=0;i<n;i++)
        B[k]=B[k]+y[i]*FL(k,x[i]);
	  }
}

//цикл создания единичной матрицы E[i][j] //
void make_E(float E[m][m])
{
	int i,j;
	for (i=0;i<m;i++)
	for (j=0;j<m;j++)
	  {
	  if (i==j) E[i][j]=1;
	  else E[i][j]=0;
	  }
}

//вывод вектора //
void vyvod_vectora(float C[n], int f)
{
	int i;
	for (i=0;i<f;i++)
	printf("%5.2f\n",C[i]);
}

//вывод двумерного массива //
void vyvod_massiva(float C[m][m])
{
	int i,j;
	for (i=0;i<m;i++)
	 {
	 for (j=0;j<m;j++)
	 printf("%5.2f ",C[i][j]);
	 printf("\n");
     }
}

//прямой ход метода гаусса//
void gauss_1(float A[m][m], float E[m][m])
{
	int i,l,j,k;
	float Q;
	for (i=0;i<m-1;i++)
	for (l=i+1;l<m;l++)
	{
	Q=A[l][i]/A[i][i];
	A[l][i]=0;
	  for (j=i+1;j<m;j++)
	  A[l][j]=A[l][j]-Q*A[i][j];
	for (k=0;k<m;k++)
	E[l][k]=E[l][k]-Q*E[i][k];
	}
}

//обратный ход метода гаусса //
void gauss_2(float A[m][m], float E[m][m],float R[m][m])
{
	int i,l,j;
	float sum;
	for (l=0;l<m;l++)
	R[m-1][l]=E[m-1][l]/A[m-1][m-1];
	  for (i=m-2;i>=0;i--) 
	  for (l=0;l<m;l++)
	  {
	  sum=E[i][l];
	  for (j=i+1;j<m;j++)  
	  sum=sum-A[i][j]*R[j][l];
	  R[i][l]=sum/A[i][i];
	  }
}

//вычисление вектора С методом обр. матрицы //
void massiv_C(float C[m], float R[m][m], float B[m])
{
	int i,k;
	for (i=0;i<m;i++)
	{
	C[i]=0;
	for (k=0;k<m;k++)
	C[i]=C[i]+R[i][k]*B[k];
	}
}

//расчет координат точек аппроксимирующей функции //
void koord_approx(float C[m],float x[n],float y[n], float Yl[n])
{
	int k,i;
	k=0;
	for (i=0;i<n;i++)
	Yl[i]=C[0]*FL(k,x[i])+C[1]*FL(k+1,x[i])+C[2]*FL(k+2,x[i]);
}

void approx_kr(float x[n],float y[n],float Yl[n], float *Dmax, float *Kr,int *IM, float *Xim)
{
	float D[n];
	int i,k;
	*Kr=0;
	for (i=0;i<n;i++)
	{
	  D[i]=y[i]-Yl[i];
	  *Kr=(*Kr)+(D[i]*D[i]);
	}
	*Dmax=D[0];
	*IM=0;
	for (i=1;i<n;i++)
	{
	if  (fabs(D[i])>fabs(*Dmax))
	  {
	  *Dmax=D[i];
	  *Xim=x[i];
	  *IM=i;
	  }
	}
}



int main()
{
	int i,j,k,IM;
	float x[n],y[n],A[m][m],B[m],R[m][m],C[m],Yl[n],Xim,Dmax,Kr,
          D[n],E[m][m];
	
          vvod_koord(x,y);  //ввод исходных данных
          printf("\n");
          printf("\n");
          massiv_A(A,x);  //расчет массива коэффициентов А
          printf("massiv A\n"); vyvod_massiva(A); printf("\n");
	massiv_B(B,x,y);  //расчет массива коэффициентов В
	printf("massiv B\n"); vyvod_vectora(B,m); printf("\n");
	make_E(E);  //создание единичной матрицы
	gauss_1(A,E);  //прямой ход метода гаусса
	gauss_2(A,E,R);  //обратный ход метода гаусса
	massiv_C(C,R,B);  //вычисление вектора С методом обр. матрицы
	printf("massiv C\n"); vyvod_vectora(C,m); printf("\n");
          koord_approx(C,x,y,Yl);  //расчет координат точек аппроксимирующей функции
          approx_kr(x,y,Yl,&Dmax,&Kr,&IM,&Xim);  //расчет критерия аппроксимации и т.д
	 
	//вывод результатов аппроксимации
	printf("\n");
	printf("kriteriy approx= %5.2f\n",Kr);
	printf("max otkloneniye= %5.2f  v tochke %i: x[%i]=%5.2f\n",Dmax,IM+1,IM+1,Xim);
	printf("\n");
	printf("znacheniya approx. funktsii\n");
          vyvod_vectora(Yl,n);
	 
      getch();
      return 0;	 
}

Заранее благодарю