复件 data.c

最小二乘法一般是用来拟合直线和一些线性数据的

#include<stdio.h>
#include<stdlib.h>
#include <string.h> 
#define D 4
#define NN 100
#define MM 10


double data[100][10] = {
??
};

void Display(double *dat, double *Answer, double *SquarePoor, int rows, int cols)
{
    double v, *p;
    int i, j,k=1;
    printf("回归方程式:\nY = %.5lf", Answer[0]);
    for (i = 1; i < cols; i ++)
        printf(" + %.5lf*X%d", Answer[i], i);
  //  printf("\n");
  //  printf("回归显著性检验:\n");
  //  printf("回归平方和：%12.4lf  回归方差：%12.4lf \n", SquarePoor[0], SquarePoor[2]);
  //  printf("剩余平方和：%12.4lf  剩余方差：%12.4lf \n", SquarePoor[1], SquarePoor[3]);
  //  printf("离差平方和：%12.4lf  标准误差：%12.4lf \n", SquarePoor[0] + SquarePoor[1], sqrt(SquarePoor[3]));
  //  printf("F   检  验：%12.4lf  相关系数：%12.4lf \n", SquarePoor[2] / SquarePoor[3],
  //         sqrt(SquarePoor[0] / (SquarePoor[0] + SquarePoor[1])));
  // printf("剩余分析: \n");
  //  printf("          ID        观察值      估计值      剩余值    剩余平方 \n");
  //  for (i = 0, p = dat; i < rows; i ++, p ++,k++)
  // {
  //      v = Answer[0];
  //      for (j = 1; j < cols; j ++, p ++)
  //          v += *p * Answer[j];
  //      printf("%12d%12.2lf%12.2lf%12.2lf%12.2lf \n",k ,*p, v, *p - v, (*p - v) * (*p - v));
 //   }
 //   system("pause");
}
void FreeData(double **dat, double *d, int count)
{
    int i, j;
    free(d);
    for (i = 0; i < count; i ++)
        free(dat[i]);
    free(dat);
}

int LinearEquations(double *data, int count, double *Answer)
{
    int j, m, n;
    double tmp, **dat, *d = data;
    dat = (double**)malloc(count * sizeof(double*));
    for (m = 0; m < count; m ++, d += (count + 1))
    {
        dat[m] = (double*)malloc((count + 1) * sizeof(double));
        memcpy(dat[m], d, (count + 1) * sizeof(double));
    }
    d = (double*)malloc((count + 1) * sizeof(double));
    for (m = 0; m < count - 1; m ++)
    {
       
        for (n = m + 1; n < count && dat[m][m] == 0.0; n ++)
        {
            if ( dat[n][m] != 0.0)
            {
                memcpy(d, dat[m], (count + 1) * sizeof(double));
                memcpy(dat[m], dat[n], (count + 1) * sizeof(double));
                memcpy(dat[n], d, (count + 1) * sizeof(double));
            }
        }
       
        if (dat[m][m] == 0.0)
        {
            FreeData(dat, d, count);
            return -1;
        }
        
        for (n = m + 1; n < count; n ++)
        {
            tmp = dat[n][m] / dat[m][m];
            for (j = m; j <= count; j ++)
                dat[n][j] -= tmp * dat[m][j];
        }
    }
    for (j = 0; j < count; j ++)
        d[j] = 0.0;

    Answer[count - 1] = dat[count - 1][count] / dat[count - 1][count - 1];
    
    for (m = count - 2; m >= 0; m --)
    {
        for (j = count - 1; j > m; j --)
            d[m] += Answer[j] * dat[m][j];
        Answer[m] = (dat[m][count] - d[m]) / dat[m][m];
    }
    FreeData(dat, d, count);
    return 0;
}


int MultipleRegression(double *data, int rows, int cols, double *Answer, double *SquarePoor)
{
    int m, n, i, count = cols - 1;
    double *dat, *p, a, b;
    if (data == 0 || Answer == 0 || rows < 2 || cols < 2)
        return -1;
    dat = (double*)malloc(cols * (cols + 1) * sizeof(double));
    dat[0] = (double)rows;
    for (n = 0; n < count; n ++)                     
    {
        a = b = 0.0;
        for (p = data + n, m = 0; m < rows; m ++, p += cols)
        {
            a += *p;
            b += (*p * *p);
        }
        dat[n + 1] = a;                              
        dat[(n + 1) * (cols + 1)] = a;               
        dat[(n + 1) * (cols + 1) + n + 1] = b;       
        for (i = n + 1; i < count; i ++)             
        {
            for (a = 0.0, p = data, m = 0; m <rows; m ++, p += cols)
                a += (p[n] * p[i]);
            dat[(n + 1) * (cols + 1) + i + 1] = a;   
            dat[(i + 1) * (cols + 1) + n + 1] = a;   
        }
    }
    for (b = 0.0, m = 0, p = data + n; m < rows; m ++, p += cols)
        b += *p;
    dat[cols] = b;                                  
    for (n = 0; n < count; n ++)
    {
        for (a = 0.0, p = data, m = 0; m < rows; m ++, p += cols)
            a += (p[n] * p[count]);
        dat[(n + 1) * (cols + 1) + cols] = a;        
    }
    n = LinearEquations(dat, cols, Answer);          

    if (n == 0 && SquarePoor)
    {
        b = b / rows;                                
        SquarePoor[0] = SquarePoor[1] = 0.0;
        p = data;
        for (m = 0; m < rows; m ++, p ++)
        {
            for (i = 1, a = Answer[0]; i < cols; i ++, p ++)
                a += (*p * Answer[i]);               
            SquarePoor[0] += ((a - b) * (a - b));    
            SquarePoor[1] += ((*p - a) * (*p - a));  
        }
        SquarePoor[2] = SquarePoor[0] / count;       
	if (rows - cols > 0.0)

    SquarePoor[3] = SquarePoor[1] / (rows - cols); 
  else
    SquarePoor[3] = 0.0;    }
    free(dat);
    return n;
}
int main()
{
    double Answer[D], SquarePoor[4];
    if (MultipleRegression((double*)data, NN, MM, Answer, SquarePoor) == 0)
        Display((double*)data, Answer, SquarePoor, NN, MM);
    return 0;
}