数值分析课程设计分析方案.docx

数值分析课程设计分析方案.docx

《数值分析课程设计分析方案.docx》由会员分享，可在线阅读，更多相关《数值分析课程设计分析方案.docx（32页珍藏版）》请在冰点文库上搜索。

数值分析课程设计分析方案

郑州轻工业学院

《数值分析》

课程设计报告

题目：

1.非线性方程求解8.最小二乘法

姓名：

杨君芳

院<系）：

数学与信息科学学院

专业班级：

信科11-01

学号：

541110010148

指导教师：

汪远征

时间：

2018年12月30日至2018年1月4日

摘要

本文的内容主要属于数值代数问题的迭代解法和差值问题。

在VC++6.0环境下对非线性方程求根的三种迭代解法<即一般迭代法，牛顿迭代法和弦截法）的算法实现，将抽象问题转化为计算机编程的一般解法思想，实现运用计算机解非线性方程的根。

同时完成了运用最小二乘法的思想解决实际问题的简单设计，

本文也对该程序设计的难点、解决技巧、每种方法的理论基础、程序的算法分析、功能分析、模块设计以及算法的优点、缺点和主要参考文献等进行了详细的作答。

，

目录

《数值分析》1

课程设计报告1

摘要2

目录3

1理论基础4

1.1非线性方程的迭代解法4

1.2最小二乘法4

2算法分析5

2.1功能分析5

2.1.1非线性方程的迭代解法5

2.2算法分析5

3程序设计8

3.1选单和主窗口设计8

3.1.1非线性方程的迭代解法8

3.1.2最小二乘法10

3.2模块设计14

3.2.1非线性方程的迭代解法14

3.2.2最小二乘法18

4总结24

5参考文献25

1理论基础

1.1非线性方程的迭代解法

1、一般迭代法：

首先将方程f

如果迭代格式产生的数列收敛，则迭代法收敛，得到的收敛值即为方程的根。

2、牛顿迭代法：

用迭代法解非线性方程总可以构造x=f

为牛顿迭代法。

3、弦截法：

用牛顿法求函数的倒数使用不方便，则可以用

代替

，则

即为弦截法

1.2最小二乘法

在研究两个变量之间的关系时，可以用回归分析的方法进行分析。

当确定了描述两个变量之间的回归模型后，就可以使用最小二乘法估计模型中的参数，进而建立经验方程。

简单地说，最小二乘的思想就是要使得观测点和估计点的距离的平方和达到最小。

里的“二乘”指的是用平方来度量观测点粤估计点的远近<在古汉语中“平方”称为“二乘”），“最小”指的是参数的估计值要保证各个观测点与估计点的距离的平方和达到最小。

2算法分析

2.1功能分析

2.1.1非线性方程的迭代解法

用三个函数来实现非线性方程的三种解法，三种方法包括<即程序中的三个模块）：

1、用一般迭代的方法解非线性方程：

编写函数FYiban（doublex>设计一个迭代格式x=f1调用函数FYiban（doublex>进行循环迭代，直到得出的结果与前一个结果的差值的绝对值小于给定的值0.00001，即为计算结果

2、用牛顿法解非线性方程：

编写函数FNewton（doublex>计算

，然后编写函数voidNewton（>实现

，其中调用函数FNewton（doublex>进行循环迭代，直到得出的结果与前一个结果的差值的绝对值小于给定的值0.00001，即为方程的根

3、用弦截法解非线性方程：

编写函数FXuanjie（doubleq,doubler>计算原方程函数的导数，然后编写函数voidXuanjie（>实现

其中调用函数FXuanjie（doubleq,doubler>进行循环迭代，直到得出的结果与前一个结果的差值的绝对值小于给定的值0.00001，即为方程的根

2.1.2最小二乘法

已知数据对

，求多项式

使得

为最小，这就是一个最小二乘问题。

2.2算法分析

通过上面各项功能的分析、分类、综合，按照模块化程序设计的要求，得到模块结构<作为后面选单设计的主要依据

2.2.1非线性方程的迭代解法

1、根据一般迭代公式：

，做出流程图如下：

定义函数fyiban

定义并初始化变量，x。

x0,e=0.00001,k=1

输入初始值x

x0=x

xk=fyiban（x0>

k++

while|x0-x|>e&&k<1000

若k<1000

真

输出近似根x

假

提示信息

2、根据牛顿迭代公式：

，做出流程图如下：

定义函数fun

定义并初始化变量，x。

x0,e=0.00001,k=1

输入初始值x

x0=x

x=x0-fun（x0>/dfun（x0>

k++

while|x0-x|>e&&k<1000

若k<1000

真

输出近似根x

假

提示信息

3、根据弦截法迭代公式：

，做出流程图如下：

定义函数fyiban

定义并初始化变量，x。

x0,e=0.00001,k=1

输入初始值x

x0=x

x=x0-_fxuanjie（x0>

k++

while|x0-x|>e&&k<1000

若k<1000

真

输出近似根x

假

提示信息

2.2.2最小二乘法

用线性函数

为例，拟合给定数据

。

算法描述：

步骤1：

输入

值，及

。

步骤2：

建立法方程组

。

步骤3：

解法方程组。

步骤4：

输出

。

3程序设计

3.1选单和主窗口设计

3.1.1非线性方程的迭代解法

主要的设计界面和代码

#include

#include

#include

doublef（doublex>

{

return2*pow（x,3>-x-1。

}

doubleFYiban（doublex>

{

returnpow（（x+1>/2,1.0/3>。

}

doubleFNewton（doublex>

{

returnx-f（x>/（6*pow（x,2>-1>。

}

doubleFXuanjie（doubleq,doubler>

{

returnq-f（q>*（q-r>/（f（q>-f（r>>。

}

doublex,x0,x1,x2,t。

voidYiban（>

{

x0=1.5。

t=1。

cout<<"一般线性迭代过程为：

"<

while（t>=0.00001>

{

x1=FYiban（x0>。

t=x0-x1。

x0=x1。

printf（"%.5lf\n",x0>。

}

printf（"一般线性迭代结果为：

%.5lf\n\n",x0>。

}

voidNewton（>

{

x0=1.5。

t=1。

cout<<"用Newton迭代过程为：

"<

while（t>=0.00001>

{

x1=FNewton（x0>。

t=x0-x1。

x0=x1。

printf（"%.5lf\n",x0>。

}

printf（"用Newton迭代结果为：

%.5lf\n\n",x0>。

}

voidXuanjie（>

{

x0=1.5。

x1=1.4。

t=1。

cout<<"用弦截法迭代过程为：

"<

while（t>=0.00001>

{

x2=FXuanjie（x1,x0>。

t=x1-x2。

x0=x1。

x1=x2。

printf（"%.5lf\n",x0>。

}

printf（"用弦截法迭代结果为：

%.5lf\n\n",x0>。

}

voidmain（>

{

cout<<"&&+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n**\t\t\t\t\t\t\t\t&&"<

cout<<"&&\t选择用一般迭代法、牛顿法、弦截法求解方程：

2*x^3-x-1=0\t&&"<

cout<<"&&\t\ta:

一般迭代法\t\t\t\t\t&&"<

cout<<"&&\t\tb:

牛顿法\t\t\t\t\t&&"<

cout<<"&&\t\tc:

弦截法\t\t\t\t\t&&"<

cout<<"&&\t\td:

三种方法<以供比较）\t\t\t\t&&"<

cout<<"&&+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&&"<

charc=getchar（>。

switch（c>

{

case'a':

Yiban（>。

break。

case'b':

Newton（>。

break。

case'c':

Xuanjie（>。

break。

case'd':

Yiban（>。

Newton（>。

Xuanjie（>。

}

}

3.1.2最小二乘法

主要的设计界面和代码

#include

#include

#include

#include

voidPrint（double**a,intm,intn>//输出函数

{

inti,j。

for（i=0。

i

i++>

{

for（j=0。

j

j++>

{

cout<<

}

cout<

}

}

//////////////////////////////////////////////////////////////////////

double**jzcj（double**a,intm,intn,double**b,intp,intq>//矩阵乘积

{

inti,j。

double**c。

c=newdouble*[m]。

for（i=0。

i

i++>

c[i]=newdouble[q]。

for（i=0。

i

i++>

{

for（j=0。

j

j++>

{

c[i][j]=0。

for（intx=0。

x

x++>

{

c[i][j]=c[i][j]+a[i][x]*b[x][j]。

}

}

}

Print（c,m,q>。

returnc。

}

///////////////////////////////////////////////

double**jzdn（double**a,intm,intn>//矩阵的逆

{

inti,j,k。

doublec,**b,**t。

b=newdouble*[m]。

//动态分配空间

for（i=0。

i

i++>

b[i]=newdouble[m]。

t=newdouble*[m]。

//动态分配空间

for（i=0。

i

i++>

t[i]=newdouble[m]。

/////////////////////////////////////////矩阵求逆

/////////////////////////////////合并构成增广矩阵

for（i=0。

i

i++>

{

for（j=0。

j

j++>

{

b[i][j]=a[i][j]。

}

for（j=m。

j<2*n。

j++>

{

if（i+m==j>

b[i][j]=1。

else

b[i][j]=0。

}

}

cout<<"___________________________________求逆过程______________________________"<

for（i=0。

i

i++>//输出增广矩阵

{

for（j=0。

j<2*m。

j++>

cout<<

cout<

}

cout<<"\n"。

/////////////////初等行变化求逆

for（i=0。

i

i++>

{

c=b[i][i]。

for（j=i。

j

j++>

b[i][j]/=c。

for（j=i+1。

j

j++>

{

c=b[j][i]。

for（k=i。

k

k++>

b[j][k]=b[j][k]-c*b[i][k]。

}

}

for（i=0。

i

i++>

{

for（j=0。

j<2*m。

j++>

cout<<

cout<

}

cout<<"\n"。

for（i=m-1。

i>=0。

i-->

{

c=b[i][i]。

for（j=i-1。

j>=0。

j-->

{

c=b[j][i]。

for（k=i。

k

k++>

b[j][k]=b[j][k]-c*b[i][k]。

}

}

for（i=0。

i

i++>

{

for（j=0。

j<2*m。

j++>

cout<<

cout<

}

for（i=0。

i

i++>

{

for（j=m。

j

j++>

t[i][j-m]=b[i][j]。

cout<<

cout<

}

returnt。

}

//////////////////////////////////////////////

double**jzzz（double**a,intm,intn>//矩阵转置

{

inti,j。

double**c。

c=newdouble*[n]。

for（i=0。

i

i++>

c[i]=newdouble[m]。

for（j=0。

j

j++>//矩阵的转置

{

for（intk=0。

k

k++>

{

c[k][j]=a[j][k]。

}

}

Print（c,n,m>。

returnc。

}

voidmain（>

{

double**a,**b,**d,**e,**f,**g,**h。

inti,j,m,n,p,q。

cout<<"请输入矩阵a的行和列:

\n"。

cin>>m>>n。

a=newdouble*[m]。

for（i=0。

i

i++>

a[i]=newdouble[m]。

cout<<"请输入矩阵a的数据:

\n"。

for（i=0。

i

i++>

{

for（j=0。

j

j++>

cin>>a[i][j]。

}//完成了对矩阵a的初始赋值

cout<<"请输入矩阵b的行和列:

\n"。

cin>>p>>q。

b=newdouble*[p]。

for（i=0。

i

i++>

b[i]=newdouble[p]。

cout<<"请输入矩阵b的数据:

\n"。

for（i=0。

i

i++>

{

for（j=0。

j

j++>

cin>>b[i][j]。

}//完成了对矩阵b的初始赋值

cout<<"_________________原始矩阵_______________"<

Print（a,m,n>。

//输出系数矩阵

cout<<"\n"。

Print（b,p,q>。

//输出常数矩阵

cout<<"系数矩阵a的转置矩阵1\n"。

d=jzzz（a,m,n>。

cout<<"系数矩阵a的转置矩阵与系数矩阵a的乘积所得矩阵2\n"。

e=jzcj（d,n,m,a,m,n>。

cout<<"系数矩阵a与其转置矩阵的乘积的逆矩阵3\n"。

f=jzdn（e,n,n>。

cout<<"矩阵的逆\n"。

Print（f,n,n>。

cout<<"系数矩阵a的转置矩阵与常数矩阵b的乘积所得矩阵4\n"。

g=jzcj（d,n,m,b,p,q>。

cout<<"最小二乘解x,y\n5"。

h=jzcj（f,n,n,g,n,q>。

}

3.2模块设计

3.2.1非线性方程的迭代解法

针对每一个模块给出主要的界面和代码

1、一般迭代法：

doubleFYiban（doublex>

{

returnpow（（x+1>/2,1.0/3>。

}

voidYiban（>

{

x0=1.5。

t=1。

cout<<"一般线性迭代过程为：

"<

while（t>=0.00001>

{

x1=FYiban（x0>。

t=x0-x1。

x0=x1。

printf（"%.5lf\n",x0>。

}

printf（"一般线性迭代结果为：

%.5lf\n\n",x0>。

}

2、牛顿迭代法：

doubleFNewton（doublex>

{

returnx-f（x>/（6*pow（x,2>-1>。

}

voidNewton（>

{

x0=1.5。

t=1。

cout<<"用Newton迭代过程为：

"<

while（t>=0.00001>

{

x1=FNewton（x0>。

t=x0-x1。

x0=x1。

printf（"%.5lf\n",x0>。

}

printf（"用Newton迭代结果为：

%.5lf\n\n",x0>。

}

3、弦截法

doubleFXuanjie（doubleq,doubler>

{

returnq-f（q>*（q-r>/（f（q>-f（r>>。

}

voidXuanjie（>

{

x0=1.5。

x1=1.4。

t=1。

cout<<"用弦截法迭代过程为：

"<

while（t>=0.00001>

{

x2=FXuanjie（x1,x0>。

t=x1-x2。

x0=x1。

x1=x2。

printf（"%.5lf\n",x0>。

}

printf（"用弦截法迭代结果为：

%.5lf\n\n",x0>。

}

4、主函数模块：

voidmain（>

{

cout<<"&&+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n**\t\t\t\t\t\t\t\t&&"<

cout<<"&&\t选择用一般迭代法、牛顿法、弦截法求解方程：

2*x^3-x-1=0\t&&"<

cout<<"&&\t\ta:

一般迭代法\t\t\t\t\t&&"<

cout<<"&&\t\tb:

牛顿法\t\t\t\t\t&&"<

cout<<"&&\t\tc:

弦截法\t\t\t\t\t&&"<

cout<<"&&\t\td:

三种方法<以供比较）\t\t\t\t&&"<

cout<<"&&+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&&"<

charc=getchar（>。

switch（c>

{

case'a':

Yiban（>。

break。

case'b':

Newton（>。

break。

case'c':

Xuanjie（>。

break。

case'd':

Yiban（>。

Newton（>。

Xuanjie（>。

}

}

针对每一个模块给出主要的界面和代码

3.2.2最小二乘法

1、输入矩阵a和b

cout<<"请输入矩阵a的数据:

\n"。

for（i=0。

i

i++>

{

for（j=0。

j

j++>

cin>>a[i][j]。

}//完成了对矩阵a的初始赋值

cout<<"请输入矩阵b的行和列:

\n"。

cin>>p>>q。

b=newdouble*[p]。

for（i=0。

i

i++>

b[i]=newdouble[p]。

cout<<"请输入矩阵b的数据:

\n"。

for（i=0。

i

i++>

{

for（j=0。

j

j++>

cin>>b[i][j]。

}//完成了对矩阵b的初始赋值

cout<<"_________________原始矩阵_______________"<

Print（a,m,n>。

//输出系数矩阵

cout<<"\n"。

Print（b,p,q>。

//输出常数矩阵

2、系数矩阵a的转置矩阵1，系数矩阵a的转置矩阵与系数矩阵a的乘积所得矩阵2：

//////////////////////////////////////////////

double**jzzz（double**a,intm,intn>//矩阵转置

{

inti,j。

double**c。

c=newdouble*[n]。

for（i=0。

i

i++>

c[i]=newdouble[m]。

for（j=0。

j

j++>//矩阵的转置

{

for（intk=0。

k

k++>

{

c[k][j]=a[j][k]。

}

}

Print（c,n,m>。

returnc。

}

3、系数矩阵a与其转置矩阵的乘积的逆矩阵3：

double**jzdn（double**a,intm,intn>//矩阵的逆

{

inti,j,k。

doublec,**b,**t。

b=newdouble*[m]。

//动态分配空间

for（i=0。

i

i++>

b[i]=newdouble[m]。

t=newdouble*[m]。

//动态分配空间

for（i=0。

i

i++>

t[i]=newdouble[m]。

/////////////////////////////////////////矩阵求逆

///////////