本人正在做毕业设计　　遇到一个问题　想请各位高手帮忙　谢谢了　
　问题：　Ｙ＝Ｂ０+Ｂ１Ｘ１+Ｂ２Ｘ２其中Ｙ，Ｘ１，Ｘ２已经给出若干组数据
现在就想根据个数据，求出Ｂ０，Ｂ１，Ｂ２ 进而拟和出这个函数方程！
　亲各位高手帮帮小弟　　不胜感激！！！

利用n组数据先求解3元方程,倒求B0,B1,B2,循环求解,最后分别平均.
您看这样行不?
这位大哥,我想帮您，但是现在没空，有人路过的话，会帮您的,没准,现在就有人在算着呢!

我现在有个FORTRAN 的程序 但是我看不明白 我想要C语言程序 哪位可以帮我翻译一下啊

二元回归（FORTRAN 77语句）

本程序计算给定的n组数据（xi,yi,zi） i=1 2 3 …… n 的二元回归方程z=a+bx+cy的值。

使用说明：

1 子程序语句

SUBROUTINE RABXCY (N,X,Y,Z,A,B,C)

2哑元说明

N 整变量 ，输入参数，数据的组数

X 数组 存放xi值

Y 数组 存放xi值

Z 数组 存放xi值

A 实变量 ，输出参数，存放系数a

B 实变量 ，输出参数，存放系数b

C 实变量 ，输出参数，存放系数c

程序：

100 SUBROUTINE RABXCY(N,X,Y,Z,A,B,C)

200 IMPLICIT REAL*8(A-H,0-Z)

300 DIMENSION X(N),Y(N),Z(N),XK(6),YK(3),AY(3,4)

400 NN=3

500 DO 10 I=1,6

600 XK(I)=0.0

700 10 CONTINUE

800 DO 20 I=1,3

900 YK(I)=0.0

1000 20 CONTINUE

1100 XK(1)=N

1200 DO 30 I=1,N

1300 XK(2)=XK(2)+X(I)

1400 XK(3)=XK(3)+Y(I)

1500 XK(4)=XK(4)+X(I)*Y(I)

1600 XK(5)=XK(5)+Y(I)**2

1700 XK(6)=XK(6)+X(I)**2

1800 YK(1)= YK(1)+Z(I)

1900 YK(2)=YK(2)+Z(I)*X(I)

2000 YK(3)=YK(3)+Y(I)*Z(I)

2100 30 CONTINUE

2200 AY(1,1)=XK(1)

2300 AY(1,2)=XK(2)

2400 AY(1,3)=XK(3)

2500 AY(1,4)=YK(1)

2600 AY(2,1)=XK(2)

2700 AY(2,2)=XK(6)

2800 AY(2,3)=XK(4)

2900. AY(2,4)=YK(2)

3000 AY(3,1)=XK(3)

3100 AY(3,2)=XK(4)

3200 AY(3,3)=XK(5)

3300 AY(3,4)=YK(3)

3400 CALL RENRTU(NN,AY)

3500 A=AY(1,4)

3600 B=AY(2,3)

3700 C=AY(3,4)

3800 RETURN

3900 END

4000 SUBROUTINE RENRTU(N,A)

4100 IMPLICIT REAL*8 (A-H,0-Z)

4200 DIMENSION A(3,4)

4300 M=N+1

4400 DO 40 K=1,N

4500 P=A(K,K)

4600 DO 10 J=K,N

4700 A(K,J)=A(K,J)/P

4800 10 CONTINUE

4900 DO 30 I=1,N

5000 IF(I.EQ.K) GO TO 30

5100 AIK=A(I,K)

5200 DO 20 J=K,N

5300 A(I,J)=A(I,J)-AIK*A(K,J)

5400 20 CONTINUE

5500 30 CONTINUE

5600 40 CONTINUE

5700 RETURN

5800 END

我也想知道

ding

大哥们   帮忙啊

还没人帮忙啊  兄弟们

请稍候，我把FORTRAN翻译成C。太饿了，先吃饭。

void RENRTU (int N,double A[][4]);

void RABXCY (int N,double X[],double Y[],double Z[],
double *A,double *B,double *C)
{
double XK[6],YK[3],AY[3][4];
int NN=3,I;
for(I=0;I<6;I++)
{
XK[I]=0.0;
}

for(I=0;I<3;I++)
{
YK[I]=0.0;
}

XK[0]=N;

for(I=0;I<N;I++)
{
XK[1]+=X[I];
XK[2]+=Y[I];
XK[3]+=X[I]*Y[I];
XK[4]+=Y[I]*Y[I];
XK[5]+=X[I]*X[I];
YK[0]+=Z[I];
YK[1]+=Z[I]*X[I];
YK[2]+=Y[I]*Z[I];
}

AY[0][0]=XK[0];
AY[0][1]=XK[1];
AY[0][2]=XK[2];
AY[0][3]=YK[0];
AY[1][0]=XK[1];
AY[1][1]=XK[5];
AY[1][2]=XK[3];
AY[1][3]=YK[1];
AY[2][0]=XK[2];
AY[2][1]=XK[3];
AY[2][2]=XK[4];
AY[2][3]=YK[2];

RENRTU(NN,AY);

*A=AY[0][3];
*B=AY[1][2];
*C=AY[2][3];
}

void RENRTU(int N,double A[3][4])
{
double P,AIK;
int I,J,K,M=N+1;
for(K=1;K<=N;K++)
{
P=A[K-1][K-1];
for(J=K;J<=N;J++)
A[K-1][J-1]/=P;

for(I=1;I<=N;I++)
{
if(I==K)continue;
AIK=A[I-1][K-1];
for(J=K;J<=N;J++)
A[I-1][J-1]-=AIK*A[K-1][J-1];
}
}
}