数理统计实验报告

内江师范学院

数 理 统 计

实  验  报  告

编制  王凡彬     审定  牟廉明

专业:   数学与应用数学   

班级:   2010      3  

学号:                    

姓名:                    

数学与信息科学学院

20##年5月


实验名称:  假设检验实验(实验三)               指导教师:  王凡彬       

实验时数:    4         实验设备:安装了VC++mathematicamatlab的计算机

实验日期:             日                  实验地点:第五教学楼北902

实验目的:

1.学会利用Excel进行假设检验的方法;

2.应用这种方法解决一些实际问题。

实验准备:

1.  在开始本实验之前,请回顾教科书的相关内容;

2. 需要一台安装有Windows XP Professional操作系统和完整安装office2003的计算机。

实验内容及要求:

1.某种电子元件的寿命(以小时计)服从正态分布,均未知,现测得16只元件的寿命如下:

159   280   101   212   224   379   179   264

222   362   168   250   149   260   485   170

问:是否有理由认为元件的平均寿命大于225(小时)?(

2.两台车床生产同一种滚珠,滚珠直径服从正态分布。从中分别抽取8个和9个产品,测得其直径为

      甲车床:15.0  14.5  15.2  15.5  14.8  15.1  15.2  14.8

乙车床:15.2  15.0  14.8  15.2  15.0  15.0  14.8  15.1  14.8

比较两台车床生产的滚珠直径的方差是否有明显差异。(

实验过程:(含程序代码及运行结果

1    (1) 打开Excel的一个新工作表,在单元格A1—A16输入样本数据159   280   101   212   224   379   179   264  222   362   168   250   149   260   485   170 如下表:

(2)计算样本平均寿命,在单元格D1中输入公式:

=AVERAGE(A1:A16)

再单击回车键就可以得到平均寿命241.5.

(3)计算标准差,在单元格D2中输入公式:

        =STDEV(A1:A16)

 再单击回车键就可以得到标准差为98.72588

(4)在单元格D3中输入样本数16

(5)在单元格D4中输入T检验值的计算公式:

         =(D1-225)/(D2/SQRT(D3))

再单击回车键就可以得到t值为0.6685177

(6)在单元格D5中输入公式

=TTNV(0.05,15)

再单击回车键就可以得到的值为2.13145

     现在的检验问题是:

                       H0:u>225; H1<=225

拒绝域为,由上面的计算得到t=0.6685177<=2.13145因此检验的结果是不拒绝原假设

可以认为元件的平均寿命大于225小时

2   (1)这是一个关于两正态总体方差的一致性检验问题,设X为甲车床生产的滚珠直径,Y为乙车床生产的滚珠直径,则有检验问题:  ,其对应拒绝域为:

(2) 打开Excel的一个新工作表. 在单元格A1中输入标记“甲车床”,在单元格B1中输入标记“乙车床”.

         在单元格A2到A9输入甲车床的样本数据:15.  14.5  15.2  15.5  14.8  15.1  15.2  14.8

   在单元格B2到B10输入乙车床的样本数据: 15.2  15.  14.8  15.2  15.  15.  14.8  15.1  14.8

如下表:

(3)计算样本的平均直径,在D2中输入公式

                                   =AVERAGE(A2:A9)

     再单击回车键就可以得到甲车床样本数据的平均直径为15.0125

       在E2中输入公式

                     =AVERAGE(B2:B10)

      再单击回车键就可以得到乙车床样本数据的平均直径为14.98889

 (4)计算样本的方差,在D3中输入公式

                        =VAR(A2:A9)

    再单击回车键就可以得到甲车床的方差为0.095536

   在E3中输入公式

                   =VAR(B2:B10)

    再单击回车键就可以得到乙车床的方差为0.026111

(5)在单元格D4中输入甲车床的观测值 8

     在单元格E4中输入乙车床的观测值 9

(6)在单元格D5中输入公式

                        =D3/E3

     单击回车键就可以得到合并方差比值为F=3.658815

(7)取显著水平=0.5,则查表就可以得到=4.53; =4.90

     则=1/=1/4.90=0.204082

  (8)在单元格D6中输入4.53

    在单元格D7中输入4.9

在单元格D8中输入公式:

                     =1/D7

就可以得到数据0.204082

(9)则就得到了拒绝域W={F>=4.53或F<=0.204082}

 由于检验计量F=3.658815不在拒绝域内,则认为两台车床生产的滚珠直径的方差没有明显差异

实验总结(由学生填写):通过这个实验我学会了用Excel去处理单个正正态分布的t检验和两个正态分布总体方差比的F检验,也巩固了课本上的重要知识点。                                                            

                                                                                                                      

 

第二篇:数理统计课程实验报告

高等数理统计课程实验

【摘要】     本实验报告描述了用最小二成估计算法解决实际问题中参数估计的过程。包括引言、实验原理、实验过程、实验结果及分析,同时给出了在实验过程中所遇到的问题描述,以及问题是否解决及待改进的地方。

              本次实验所采用的编程工具为Visual studio 2008,编程语言采用C++。

        

1 引言:

实验目的:应用参数估计方法解决实际问题。

实验意义:通过本次实验,更加熟烂的掌握最小二成估计算法。使用实验中给出的数据选用适当的函数(如适当阶次的多项式、高斯势函数),用LS估计方法,拟合给定数据,给出拟合强度系数以及噪声方差(设为独立高斯噪声)。

2 原理:y = a+bx + e,其中y、x 可测, e是均值为0的随机变量,a、 b为未知参数。通过 n次实验,得到测量数据yi和xi, i = 1, 2, …, n,

确定未知参数 a 、 b。使

 

的估计称为最小二乘(LS)估计,即残差平方和最小的估计。

基本模型 :

写为向量形式为:

写为矩阵形式为:

其中:

 

拟合强度系数推导公式为:^β=(X’X)X’Y

所以拟合后的函数值为:  ^Y=X^β

残差平方和计算公式如下:

 


噪声方差计算公式:Yawp=J(a)/(p-n) 

其中p为矩阵Y的行数,n为所使用的阶数。

3 实验结果及分析:

双括号: 1  10  102   103…… 10n
1  20  202  203……20n
1  30  302   303…….30n
…………………………………………….1  167 1672 1673........167n
.
.
.
.
 


 构造X为:         

 X=

                     

 

Y=

                                           共167个数据

输入不同的N进行实验,观察不同的N值所对应的残差平方和及噪声方差:

下图中黑线为原始数据所对应的函数图,红色为N阶拟合函数图。

以下列举几个比较具有代表性的N值所对应的拟合函数及对应的残差平方和与噪声方差。

(1)取N=3

实验结果如下:

(2)取N=9

(3)取N=13

(4)取N=17

(5)取N=40

观察以上N阶拟合函数,发现当N=17时拟合效果最好,即在N=17时残差平方和最小。

4 小结

试验中遇到的一些问题:

(1)在写求矩阵的逆矩阵的算法时,要先判断该矩阵的行列式是否为0,由于逻辑错误,导致程序进入死循环。

解决方法:不在程序中判断矩阵的行列式是否为0,改为在实验过程中保证所涉及的矩阵行列式都不为0,再进行运算。

(2)描述一个矩阵时要用一个数组及x,y来描述,但是这样曾加了结构复杂度,导致整体结构复杂。

解决方法:用一个结构体封装这个矩阵,结构体里包含存放数据的数组及表示行数列数的x,y。

(3)开始把数据类型定义为DOUBLE,但是在计算N很大时有可能发出溢出。

解决方法:使用第三方高精度浮点数运算库函数。

但是由于能力有限,该错误还是存在,例如上面当N=17时,残差平方和很小,但拟合函数在后期却显示出与原函数偏差很大,估计就是由这一未解决的问题引起的。

5 参考文献

[1]孙荣恒.应用数理统计[M]. 北京:科学出版社,2003.

[2]夏普(英). Visual studio 2008从入门到精通[M].北京:清华大学出版社,2009.

[3]同济大学应用数学系.线性代数[M].北京:高等教育出版社,2003.

6 附录:

主要程序代码:

(1)求矩阵转置的算法:

tatic int MatrixAlgo::Transpose(Matrix<T>& matrix)

{

     int nxTmp; //转置后的x

     int nyTmp; //转置后的y

     nxTmp = matrix.ny;   

     nyTmp = matrix.nx;

     T *tmp_matrix_arry = new T[nxTmp*nyTmp];

     if(tmp_matrix_arry == NULL)

         return 0;

     for(int x = 0; x < matrix.nx; ++x)

     {

         for(int y = 0; y < matrix.ny; ++y)

         {

              tmp_matrix_arry[y*nyTmp + x] = matrix.matrix_arry[x*matrix.ny + y];

         }

     }

     T* delete_tmp = matrix.matrix_arry;

     matrix.matrix_arry = tmp_matrix_arry;

     matrix.nx = nxTmp;

     matrix.ny = nyTmp;

     delete[] delete_tmp;

     return 1;

}

(2)求矩阵逆矩阵的算法:

static int MatrixAlgo::Inverse(Matrix<T>& matrix)

{

     if(matrix.nx != matrix.ny)

         return 0;

     int n = matrix.nx;

     int *is, *js, i, j, k, l, u, v;

     T d, p;

     is = new int[n];

     js = new int[n];

// 开始计算逆矩阵

     for(k = 0; k <= n-1; k++) 

     {

         d = 0.0;  

         for(i = k; i <= n-1; i++)  

         {  

              for(j = k; j <= n-1; j++)   

              {    

                   l = i * n + j;    

                   p = fabs(matrix.matrix_arry[l]);    

                   if(p > d)    

                   {     

                       d = p;     

                       is[k] = i;     

                       js[k] = j;   

                   }   

              } 

         }

         if(is[k] != k) 

         {  

              for(j = 0; j <= n-1; j++)   

              {    

                   u = k * n + j;    

                   v = is[k] * n + j;    

                   p = matrix.matrix_arry[u];    

                   matrix.matrix_arry[u] = matrix.matrix_arry[v];    

                   matrix.matrix_arry[v] = p;   

              }  

         }

         if(js[k] != k)  

         {  

              for(i = 0; i <= n-1; i++)   

              {    

                   u = i * n + k;    

                   v = i * n + js[k];    

                   p = matrix.matrix_arry[u];    

                   matrix.matrix_arry[u] = matrix.matrix_arry[v];    

                   matrix.matrix_arry[v] = p;   

              } 

         }

         l = k * n + k;  

         matrix.matrix_arry[l] = 1.0/matrix.matrix_arry[l];  

         for(j = 0; j <= n-1; j++) 

         {  

              if(j != k)   

              {    

                   u = k * n + j;    

                   matrix.matrix_arry[u] = matrix.matrix_arry[u] * matrix.matrix_arry[l];   

              } 

         }

         for(i = 0; i <= n-1; i++) 

         {  

              if(i != k)  

              {   

                   for(j = 0; j <= n-1; j++)    

                   {    

                       if (j != k)     

                       {      

                            u = i * n + j;      

                            matrix.matrix_arry[u] = matrix.matrix_arry[u] - matrix.matrix_arry[i * n + k] * matrix.matrix_arry[k * n + j];     

                       }   

                   }  

              } 

         }

         for(i = 0; i <= n-1; i++) 

         {  

              if(i != k)   

              {    

                   u = i * n + k;    

                   matrix.matrix_arry[u] = -matrix.matrix_arry[u] * matrix.matrix_arry[l];  

              }  

         }

     }

     for(k = n-1; k >= 0; k--) 

     {  

         if(js[k] != k)  

         {  

              for(j = 0; j <= n-1; j++)   

              {    

                   u = k * n + j;   

                   v = js[k] * n + j;    

                   p = matrix.matrix_arry[u];    

                   matrix.matrix_arry[u] = matrix.matrix_arry[v];    

                   matrix.matrix_arry[v] = p;   

              } 

         }

         if(is[k] != k)  

              for(i = 0; i <= n-1; i++)  

              {   

                   u = i * n + k;   

                   v = i * n + is[k];   

                   p = matrix.matrix_arry[u];   

                   matrix.matrix_arry[u] = matrix.matrix_arry[v];   

                   matrix.matrix_arry[v] = p;  

              } 

     } 

     delete [] is; delete [] js;

     return 1;

(3)矩阵乘法算法:

static Matrix<T>*  MatrixAlgo::Multiplication(Matrix<T>& matrix_lift, Matrix<T>& matrix_right)

{

     Matrix<T>*  tmp_matrix = new Matrix<T>;

     if(matrix_lift.ny != matrix_right.nx)   //非法

     {

         return NULL;

     }

     int nxTmp = matrix_lift.nx; //乘法后的x

     int nyTmp = matrix_right.ny;//乘法后的y

     T* tmp_matrix_arry = new T[nxTmp * nyTmp];

     if(tmp_matrix_arry == NULL)

     {   

         return NULL;

     }

     int i,j,l,u;

     for(i = 0; i <= nxTmp-1; i++)

     {

         for(j = 0; j <= nyTmp-1; j++)

         {

              u = i * nyTmp + j;

              tmp_matrix_arry[u] = 0;

              for(l = 0; l <= matrix_lift.ny-1; l++)

              {

                   tmp_matrix_arry[u] = (tmp_matrix_arry[u] + matrix_lift.matrix_arry[i * matrix_lift.ny + l] * matrix_right.matrix_arry[l * nyTmp + j]);

              }

         }

     }

     //T* delete_tmp = matrix.matrix_arry;

     tmp_matrix->matrix_arry = tmp_matrix_arry;

     tmp_matrix->nx = nxTmp;

     tmp_matrix->ny = nyTmp;

     //delete[] delete_tmp;

     return tmp_matrix;

}

(4)计算^β,依次调用函数顺序为:

     int SetXMatrix(int rank, int space);

     int SetYMatrix(int* arry, int n);

     void Clear();

     void XClear();                               具体函数算法见附件“实验”。

     void YClear();

     int ComputeBeta();

     Matrix<long double>* GetBeta();

   

注:要先设置Y,再根据Y设置X,否则会导致失败。(因为Y中的数据有缺失。)

(5)计算^Y:

     Matrix<long double>* GetFileMatrix();

(6)计算残差平方和,调用函数:

     long GetE();                    //获取E         具体函数算法见附件“实验”。

(7)计算噪声方差,调用函数:

float GetYawp();    

可执行程序见附件。

相关推荐