数值分析课程设计---线性方程组求解

上传人：奔*** IP属地：河北更新时间：2024-03-01 格式：doc 页数：29 大小：391.50KB 人气指数：12 举报 版权申诉

已阅读1页，还剩28页未读，继续免费阅读

版权说明：本文档由用户提供并上传，收益归属内容提供方，若内容存在侵权，请进行举报或认领

文档简介

1、　　课程设计报告　　课程名称数值分析 　　课题名称线性方程组求解 　　专业信息与计算科学 　　班级

2、 　　学号 　　姓名 　　指导教师 　　2012 年 12 月 13 日</p&g

3、t;　　一、设计内容与设计要求　　1．设计内容：　　对课程《计算方法》中的常见算法进行综合设计或应用（具体课题题目见后面的供选题目）。　　2．设计要求：　　课程设计报告正文内

4、容　　a.问题的描述及算法设计；　　b.算法的流程图（要求画出模块图）；　　c.算法的理论依据及其推导；　　d.相关的数值结果（通过程序调试)，；　　e.数值计算结果的分析；　　f.附件（

5、所有程序的原代码，要求对程序写出必要的注释）。　　书写格式　　a．要求用A4纸打印成册　　b．正文格式：一级标题用3号黑体,二级标题用四号宋体加粗,正文用小四号宋体;行距为22。　　c．正文的内容:正文总字数要求在3000字左右（不含

6、程序原代码）。　　d．封面格式如下页。　　考核方式　　指导老师负责验收程序的运行结果，并结合学生的工作态度、实际动手能力、创新精神和设计报告等进行综合考评，并按优秀、良好、中等、及格和不及格五个等级给出每位同学的课程设计成绩。具体考核标准包含以下几个部分：

7、　　a．平时出勤（占10%）　　b．系统需求分析、功能设计、数据结构设计及程序总体结构合理与否（占10%）　　c．程序能否完整、准确地运行，个人能否独立、熟练地调试程序（占40%）　　d．设计报告（占30%）　　注意：不得抄袭他人的报告（或给他人抄

8、袭），一旦发现，成绩为零分。　　e．独立完成情况（占10%）。　　课程验收要求　　a．判定算法设计的合理性，运行相关程序，获得正确的数值结果。　　b．回答有关问题。<

9、p>　　c．提交课程设计报告。　　d．提交软盘（源程序、设计报告文档）。　　e．依内容的创新程度，完善程序情况及对程序讲解情况打分。　　三、进度安排　　班级：信息与计算科学：1001、1002、1003

10、　　主讲教师： 　　辅导教师： 　　上机时间安排：　　第 12 周星期一 8时：30分——11时：30分　　星期三 8时：30分—

11、—11时：30分　　星期五 8时：30分——11时：30分　　第 13 周星期三 8时：30分——11时：30分　　星期五 8时：30分——11时：30分　　目录　　封面……………

12、……………………………………………………(01)　　任务书………………………………………………………………(02)　　目录…………………………………………………………………(05)　　问题的描述及算法设计……………………………………………(06)　　算法流程图………………

13、…………………………………………(07)　　算法的理论依据及其推导…………………………………………(08)　　相关的数值结果……………………………………………………(12)　　数值计算结果的分析………………………………………………(15)　　附件…………………………………

14、………………………………(15)　　课程设计评分表……………………………………………………(31)　　一、问题的描述及算法设计　　1、问题描述：　　设有线性方程组,其中，为非奇异矩阵,方程组的增广矩阵为<

15、p>　　在科技计算中，求解线性方程组的问题是经常遇到的，虽然线性代数课程中已涉及不少求解线性方程组的方法，但那是理论上的分析求解方法，不能简单套用到数值计算中。　　线性方程组的数值解法在计算方法课程中占有重要的地位。它大致分为迭代法和直接法两大类。　　2、算法设计<

16、;b>　　2.1直接法：　　在不考虑舍入误差的情况下，经有限步四则运算求得精确解，当n<100及某些大型稀疏方程组、带型方程组常选用直接解法。　　最基本的直接解法是Gauss消去法，其他重要的直接解法全都受到Gauss消去法的启示,此外还有LU分解法。　　2.2迭

17、代法：　　基于一定迭代格式，产生逼近方程组精确解的近似序列，当n>100，特别是某些偏微分方程数值求解过程中出现的方程组常选用迭代解法。　　相关理论包括：迭代的收敛性、收敛速度问题、误差估计，常用的迭代法是：Jacobi迭代法、Gauss－Seidel迭代法、SOR方法。

18、;　　二、算法流程图：　　三、算法的理论依据及其推导　　高斯消去元法：　　首先在的第1列选取绝对值最大的元素作为主元素，即选择　　然后交换的第1行与第行（交换后增广矩阵为简单起见仍记为，其元素仍记为）。经过第1次消

19、元得到与原方程组等价的方程，　　其中，　　上述过程可记为 　　重复上述计算过程，现假设已完成第步的选主元素过程，交换两行并进行消元计算，此时约化为　　其中的元素仍记为，的元素仍记为.第步选主元

20、素（在右下角方阵的第1列内选），即确定，使　　交换第行与行的元素，再进行消元计算，最后将原线性方程组化为　　回代可求解得　　LU分解　　若线性方程组系数矩阵A的各阶顺序主子式都不为零，则一定存在唯

21、一的矩阵分解关系　　其中，L和U分别为下三角矩阵和上三角矩阵，他们的形式为　　这种特殊的分解形式称为矩阵的Doolittle分解。　　若线性方程组的，则线性方程组可变形为　　令，则，可分裂为两个等价的方程组　　由于L和U都是三角矩

22、阵，这两个方程组都可以通过简单的回代过程求解。可见，系数矩阵分解为求线性方程组带来可行性和方便。　　Jacobi迭代：　　根据方程组中第i个方程，将未知量Xi用其余的未知量表示出来。　　构造迭代格式：<p&g

23、t;　　将上面的格式写成矩阵乘法的形式，等价与下面的矩阵方程　　其中，L，D，U分别是原方程组Ax=b中系数矩阵A的对角线下方元素、对角线元素、对角线上方元素构成的矩阵，即　　A=L+D+U　　可见，Jacobi迭代法中的迭代矩阵为

24、　Gauss－Seidel迭代法　　在Jacobi迭代法中，注意到计算时，从一直到都已经计算好，然而Jacobi迭代法并没有利用这些最新的近似值进行下一步的计算，仍用第k步的各个x进行迭代。为此，我们对Jacobi迭代格式进行如下修改：　　一旦有未知量最新的近似值，下面就用最新结果进行迭代，这样可能使收敛速度加快，同时节省存储空间

25、　　将上面的方程组写成矩阵乘法形式：　　Gauss－Seidel迭代法的迭代矩阵为：　　Jacobi迭代收敛时，Seidel迭代未必收敛；反之后者收敛时，前者也未必收敛；一般来说，当二者都收敛时，Seidel迭代收敛速度要快一些。　　逐次超松弛迭代法（SOR）法<

26、p>　　由G－S迭代格式 　　可见，G－S迭代法再计算第k＋1步的近似值时，实质上是在第k步近似值的基础上，加上一个修正量。　　为了获得更快的收敛效果，在修正量前乘一个松弛因子 W　　适当选取松弛因子，可望得到收敛速度更快的迭代格式，种方法就称为逐次松弛迭代法，简称SO

27、R (successive over relaxation)法。　　该方法收敛的必要条件是 : o<w<2，w=1时，就是G－S迭代法；当w>1时，称为逐次超松弛法；当w<1时，称为逐次低松弛法。　　四、相关的数值结果　　1.输入方程

28、维数　　2.输入矩阵并点击“增广矩阵输入好了”　　3.点击不同的方法按钮进行解答　　高斯消去　　LU分解　　Jaco

29、bi迭代　　Gauss-Seidel迭代　　SOR迭代　　4.保存文件　　五、数值计算结果的分析　　当输入的线性方程组是收敛的，可以运

30、用高斯消主元法，当输入的方程组是收敛的，既可以用高斯消主元法也可以用三种迭代方法计算。　　当方程组不收敛时，高斯消主元法是求解线性方程组最常用的方法，只要矩阵A的行列式大于零，就可以解得相应的X。　　当方程组收敛时，将三种迭代法的解和高斯消主元的解进行比较会发现，当迭代次数K越大，其方程组的解的值越接近高斯消主元的解，且当迭代次数越大第K次的X[i]与第

31、（K-1）次的X[i]的绝对值越接近与零。　　六、附件（所有程序的原代码，要求对程序写出必要的注释）　　public class LinearEquations implements ActionListener {　　Jframe jf = new Jframe();&

32、lt;b>　　int n;　　double[][] d;　　String str;　　public static void main(String[] args) {　　// 删除以前保存的文件　　new

33、 File("c:\\保存.doc").delete();　　LinearEquations itt = new LinearEquations();　　itt.lauchFrame();　　}　　private

34、void lauchFrame() {　　// 加载界面　　jf.lauchMainFrame();　　// 为p1、p3的按钮加监听　　jf.b1_1.addActionListener(this);<

35、p>　　jf.b1_2.addActionListener(this);　　jf.b3_1.addActionListener(this);　　jf.b3_2.addActionListener(this);　　jf.b3_3.addActionListener(this);<

36、p>　　jf.b3_4.addActionListener(this);　　jf.b3_5.addActionListener(this);　　jf.b3_6.addActionListener(this);　　jf.b3_7.addActionListener(this);<

37、p>　　}　　public void actionPerformed(ActionEvent e) {　　if (e.getSource() == jf.b1_1) {　　try {　　n

38、= Integer.parseInt(jf.tf1_1.getText());　　if (n >= 10 || n <= 0) {　　jf.p2.removeAll();　　jf.horizontal3_2.remove(jf.vertical3_2_1);

39、　jf.p3.remove(jf.horizontal3_1);　　jf.horizontal1_2.remove(jf.b1_2);　　jf.ta.setText("请输入1-9的维数N！");　　} else {

40、;　　jf.ta.setText("");　　jf.initMatrix(n);　　}　　} catch (NumberFormatException nfe) {　　jf.p2.removeAll();</

41、p>　　jf.horizontal3_2.remove(jf.vertical3_2_1);　　jf.p3.remove(jf.horizontal3_1);　　jf.horizontal1_2.remove(jf.b1_2);　　jf.ta.setText("维数N输入错误

42、，请重新输入！");　　}　　} else if (e.getSource() == jf.b1_2) {　　d = new double[n][n + 1];　　for (int i = 0; i < d.lengt

43、h; i++) {　　for (int j = 0; j < d[i].length; j++) {　　try {　　d[i][j] = Double.parseDouble(jf.tf2_1[i][j].getText());

44、　　jf.ta.setText("矩阵输入正确，请选择方法进行求解");　　} catch (Exception e2) {　　jf.ta.setText("输入的矩阵不对，请重新输入");　　}

45、;　　}　　}　　}　　try {　　if (e.getSource() == jf.b3_1) {

46、　　jf.ta.setText(str = new Gauss(n, d).getSb());　　} else if (e.getSource() == jf.b3_2) {　　jf.ta.setText(str = new LU(n, d).getSb());　　} else if (e.

47、getSource() == jf.b3_3) {　　jf.ta.setText(str = new Jacobi(n, d).getSb());　　} else if (e.getSource() == jf.b3_4) {　　jf.ta.setText(str = new Gauss_Seidel(n, d)

48、.getSb());　　} else if (e.getSource() == jf.b3_5) {　　jf.ta.setText(str = new SOR(n, d).getSb());　　}　　} catch (Exceptio

49、n e1) {　　jf.ta.setText("请输入正确的矩阵并且点击“矩阵输入好了”！！！");　　}　　//保存文件　　if (e.getSource() == jf.b

50、3_6) {　　FileWriter fw = null;　　try {　　if (str == null) {　　jf.ta.setText("没有任何可保存的数据！！！");<p&

51、gt;　　} else {　　jf.ta.setText("文件保存目录C:\\保存.doc");　　fw = new FileWriter("c:\\保存.doc", true);　　SimpleDateFormat sdf = ne

52、w SimpleDateFormat("yyyy-MM-dd HH:mm:ss");　　String time = "\n保存时间:" + sdf.format(new java.util.Date());　　fw.write(time + "\n" + str + "\n"

53、);　　}　　} catch (Exception e1) {　　jf.ta.setText("数据写入异常！！！");　　} finally {　　tr

54、y {　　if (fw != null) {　　fw.close();　　}　　} catch (IOException e1) {　　jf.ta.setText(&quo

55、t;数据写入异常！！！");　　}　　}　　} else if (e.getSource() == jf.b3_7) {　　// 打开文件</

56、p>　　try {　　if (new File("C:\\保存.doc").exists()) {　　Runtime.getRuntime().exec(　　"C:\\Program Files (x86)\\Micr

57、osoft Office\\"　　+ "Office14\\winword.exe C:\\保存.doc");　　} else {　　jf.ta.setText("文件不存在，请先点击保存！！！");&

58、lt;p>　　}　　} catch (IOException e1) {　　jf.ta.setText("文件打开失败！！！");　　}　　}</

59、b>　　}　　//保留四位小数　　public static double keep(double d) {　　BigDecimal b = new BigDecimal(d);</p

60、>　　return b.setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();　　}　　}　　public class Jframe {

61、　　Frame f = new JFrame("数值分析：解线性方程组作者：刘俊伟");　　Panel p1 = new Panel();　　Panel p2 = new Panel();　　Panel p3

62、 = new Panel();　　Label l1 = new Label("请输入方程维数N：");　　TextField tf1_1 = new TextField(5);　　TextField[][] tf2_1;　　Button b1_1 =

63、new Button("确定");　　Button b1_2 = new Button("增广矩阵输入好了");　　Box vertical1 = Box.createVerticalBox();　　Box horizontal1_1 = Box.createHorizon

64、talBox();　　Box horizontal1_2 = Box.createHorizontalBox();　　Box vertical3 = Box.createVerticalBox();　　Box horizontal3_1 = Box.createHorizontalBox();

65、　　Box horizontal3_2 = Box.createHorizontalBox();　　Box vertical3_2_1 = Box.createVerticalBox();　　Button b3_1 = new Button("高斯消去");　　Butto

66、n b3_2 = new Button("LU分解");　　Button b3_3 = new Button("Jacobi迭代");　　Button b3_4 = new Button("Gauss-Seidel迭代");　　Button b3_5 =

67、 new Button("SOR迭代");　　Button b3_6 = new Button("保存文件");　　Button b3_7= new Button("打开文件");　　int N = 4;　　do

68、uble[][] d;　　TextArea ta = new TextArea("尊敬的用户：\n" 　　+" 你好！\n"　　+" 欢迎使用解线性方程组程序，线程方程组解法分两种：直接法和迭代法。\n"<p&g

69、t;　　+"本程序提供的直接法有Gauss消去、LU分解，迭代法有Jacobi、Gauss_Seidel、\n" 　　+"SOR迭代法，你可以选择你需要的方法进行求解。\n"　　+" 如果本程序存在BUG，请联系本人，本人将及时修复，谢谢使用！");

70、;　　public void lauchMainFrame() {　　//根据维数大小，矩阵自动变化　　if(this.N < 5) {　　f.setBounds(400, 40, 520, 650);　　} else {<

71、;/p>　　f.setBounds(400-(N-4)*50, 70-(N-4)*5, 130*N, 600+(N-4)*10);　　}　　//三个面板　　f.add(p1);<p

72、>　　f.add(p2);　　f.add(p3);　　// 面板一　　p1.add(vertical1);　　vertical1.add(horizontal1_1);　　vertica

73、l1.add(horizontal1_2);　　horizontal1_1.add(l1);　　horizontal1_1.add(tf1_1);　　horizontal1_1.add(b1_1);　　// 面板三

74、　　p3.add(vertical3);　　p3.add(horizontal3_2);　　horizontal3_1.add(b3_1);　　horizontal3_1.add(b3_2);　　horizontal3_1.add(b3_3);<

75、;/p>　　horizontal3_1.add(b3_4);　　horizontal3_1.add(b3_5);　　horizontal3_2.add(ta);　　vertical3_2_1.add(b3_6);　　vertical3_2_1.

76、add(b3_7);　　f.setLayout(new GridLayout(3, 1));　　f.setVisible(true);　　}　　public void initMatrix(int n) {&l

77、t;p>　　this.N = n;　　//移除上次输入的矩阵　　p2.removeAll();　　Panel[][] p = new Panel[n][n+1];　　Label[][] labels = new Label[n][n+1];&

78、lt;p>　　tf2_1 = new TextField[n][n+1];　　p2.setLayout(new GridLayout(n, n+1));　　for(int i = 0; i < tf2_1.length; i ++) {　　for(int j = 0; j < tf2_1[i].

79、length; j++) {　　p[i][j] = new Panel();　　if(j < tf2_1[i].length-1) {　　labels[i][j] = new Label("a"+(i+1)+(j+1));　　}

80、 else {　　labels[i][j] = new Label("常数项");　　}　　tf2_1[i][j] = new TextField(1);　　p[i][j].add(labels

81、[i][j]);　　p[i][j].add(tf2_1[i][j]);　　p2.add(p[i][j]);　　}　　}　　ta.setText("

82、;请输入矩阵，输好后请点击“矩阵输入好了”");　　horizontal1_2.add(b1_2);　　p3.add(horizontal3_1);　　horizontal3_2.add(vertical3_2_1);　　lauchMainFrame();<

83、;/p>　　}　　}　　public class Gauss {/* 高斯消去法*/　　double a[][]; // 系数矩阵　　double b[]; /

84、/ 常数　　double x[]; // x的值　　int n; // n阶　　StringBuilder sb = new StringBuilder("高斯消去法:\n\n");　　public Gauss(int n, double[]

85、[] d) {　　this.n = n;　　a = new double[n][n];　　b = new double[n];　　x = new double[n];　　for (int i = 0; i < n; i++)

86、 {　　b[i] = d[i][n];　　for (int j = 0; j < n; j++) {　　a[i][j] = d[i][j];　　}　　}</b&g

87、t;　　elimination();　　back_substitution();　　print2();　　}　　//简单顺序消去法<

88、;/b>　　private void elimination() {　　for(int i = 0; i < n; i++) {　　if(a[i][i] == 0) {　　sb.append("对角元素"+a[i][i]+"为零，

89、程序终止！！！");　　break;　　}　　}　　for(int k = 0; k < n; k++) {<p

90、>　　for(int i = k + 1; i < n; i++) {　　double l = a[i][k] / a[k][k];　　for(int j = k; j < n; j++) {　　a[i][j] = a[i][j] - l * a[k][j];//消元&l

91、t;p>　　}　　b[i] = b[i] - l * b[k];　　}　　sb.append("第" + (k+1) + "次消去后的增广矩阵为：\n");<p&

92、gt;　　print1();　　}　　}　　//回代法求解线性方程组的解　　private void back_substitution() {</p&

93、gt;　　x[n-1] = b[n-1] / a[n-1][n-1];　　for (int i = n - 2; i >= 0; i--) {　　x[i] = (b[i] - jisuan(i)) / a[i][i];　　}

94、　　}　　private double jisuan(int i) {　　double d = 0.0;　　for (int j = i + 1; j < n; j++) {　　d = d + x[j] * a

95、[i][j];　　}　　return d;　　}　　private void print1() {　　for (in

96、t i = 0; i < n; i++) {　　for (int j = 0; j < n; j++) {　　sb.append( LinearEquations.keep(a[i][j]) + "\t");　　}&l

97、t;p>　　sb.append(LinearEquations.keep(b[i]));　　sb.append("\n");　　} 　　sb.append("\n");

98、　}　　private void print2() {　　sb.append("方程组的根为：\n");　　for (int i = 0; i < n; i++)　　sb.append("X" + (i+1

99、) + " = " + LinearEquations.keep(x[i])+"\t");　　}　　public String getSb() {　　return this.sb.toString();<p

100、>　　}　　}　　public class LU { /* LU分解法*/　　double a[][]; // 系数矩阵　　double b[]; // 常数&

101、lt;p>　　double x[]; // x的值　　int n; // n阶　　double[][] l;　　double[][] u;　　double[] y;　　StringBuilder sb = new

102、StringBuilder("LU分解法:\n\n");　　LU(int n, double[][] d) {　　this.n = n;　　a = new double[n][n];　　b = new double[n];<

103、;p>　　l = new double[n][n];　　u = new double[n][n];　　y = new double[n];　　x = new double[n];　　for (int i = 0; i < n; i++) {

104、　　b[i] = d[i][n];　　for (int j = 0; j < n; j++) {　　a[i][j] = d[i][j];　　}　　}

105、　　luResolve();　　sb.append("y的值为：\n");　　backSolvey();　　sb.append("x的值为：\n");　　backSolvex();<

106、;p>　　}　　// LU分解法　　private void luResolve() {　　for (int j = 0; j < n; j++) {　　u[0][j] = a[0][

107、j];　　}　　for (int i = 0; i < n; i++) {　　l[i][0] = a[i][0] / u[0][0];　　l[i][i] = 1;　　}

108、　　for (int r = 1; r < n; r++) {　　for (int i = r; i < n; i++) {　　u[r][i] = a[r][i] - jisuan1(r, i);　　}

109、　　for (int i = r + 1; i < n; i++) {　　l[i][r] = (a[i][r] - jisuan2(r, i)) / u[r][r];　　}　　}</p

110、>　　sb.append("单位下三角阵L为：\n");　　print2(l);　　sb.append("单位上三角阵U为：\n");　　print2(u);　　}&

111、lt;/p>　　// 回代求出y的值　　private void backSolvey() {　　y[0] = b[0] / l[0][0];　　for (int i = 1; i < n; i++) {　　y[i] = (b[i] -

112、jisuany(i)) / l[i][i];　　}　　print1(y);　　}　　private double jisuany(int i) {//1

113、　double sum = 0;　　for (int k = 0; k < i; k++) {　　sum = sum + l[i][k] * y[k];　　}　　return sum;&

114、lt;b>　　}　　// 回代求出x的值　　private void backSolvex() {　　x[n - 1] = y[n - 1] / u[n - 1][n - 1];　　for (int i = n - 2; i >= 0; i

115、--) {　　x[i] = (y[i] - jisuanx(i)) / u[i][i];　　}　　print1(x);　　}　　private doubl

116、e jisuanx(int i) {　　double sum = 0;　　for (int k = i + 1; k < n; k++) {　　sum = sum + u[i][k] * x[k];　　}

117、　　return sum;　　}　　// 打印一维矩阵　　private void print1(double[] d) {　　for (int i = 0; i < n;

118、 i++) {　　sb.append(LinearEquations.keep(d[i]) + "\t");　　}　　sb.append("\n");　　}

119、　　// 打印二维矩阵　　private void print2(double array1[][]) {　　for (int i = 0; i < n; i++) {　　for (int j = 0; j < n; j+

120、+)　　sb.append(LinearEquations.keep(array1[i][j]) + "\t");　　sb.append("\n");　　}　　sb.append("\

121、n");　　}　　private double jisuan1(int r, int i) {　　double sum = 0;　　for (int k = 0; k <= r - 1; k++) {

122、;　　sum = sum + l[r][k] * u[k][i];　　}　　return sum;　　}　　private double jisuan2(int r, int

123、 i) {　　double sum = 0;　　for (int k = 0; k <= r; k++) {　　sum = sum + l[i][k] * u[k][r];　　}　　re

124、turn sum;　　}　　public String getSb() {　　return this.sb.toString();　　}

125、　　}　　public class Jacobi {/* Jacobi迭代法*/　　double a[][]; // 系数矩阵　　double b[]; // 常数数组　　double x[]; // 方程的解数组</

126、p>　　int n; // n阶　　double x0[];　　boolean th = true;　　int count = 0;　　double e = 0; // 精度　　Str

127、ingBuilder sb = new StringBuilder("Jacobi迭代:\n\n");　　public Jacobi(int n, double[][] d) {　　this.n = n;　　a = new double[n][n];

128、　b = new double[n];　　x0 = new double[n];　　x = new double[n];　　for (int i = 0; i < n; i++) {　　b[i] = d[i][n];　　fo

129、r (int j = 0; j < n; j++) {　　a[i][j] = d[i][j];　　}　　}　　e = 5;<

130、;p>　　iteration(e);　　}　　private void iteration(double e) {　　for(int i = 0; i < n; i++) {　　if(a[i][i] == 0) {<

131、/p>　　sb.append("对角元素"+a[i][i]+"为零，程序终止！！！");　　break;　　}　　}</p&g

132、t;　　double sum = 0;　　for (int i = 0; i < x0.length; i++) {　　x0[i] = 1; //初值都为1　　}　　while (th) {</p&

133、gt;　　if(count > 100) {　　sb = new StringBuilder("Jacobi迭代:\n\n迭代次数超过100次，此线性方程采用Jacobi迭代应该不收敛");　　break;

134、}　　count++;　　for (int i = 0; i < x0.length; i++) {　　sum = 0;　　for (int j = 0; j <

135、x0.length; j++) {　　if (i!=j) {　　sum = sum + a[i][j] * x0[j];　　}　　}　　x[i] = (b

136、[i] - sum) / a[i][i];　　}　　sb.append("第" + count + "次迭代的值:\n");　　print1(x);　　if (jisuan() < Mat

众赏文库> 全部分类> 毕业设计

温馨提示

1. 本站所有资源如无特殊说明，都需要本地电脑安装OFFICE2007和PDF阅读器。图纸软件为CAD,CAXA,PROE,UG,SolidWorks等.压缩文件请下载最新的WinRAR软件解压。
2. 本站的文档不包含任何第三方提供的附件图纸等，如果需要附件，请联系上传者。文件的所有权益归上传用户所有。
3. 本站RAR压缩包中若带图纸，网页内容里面会有图纸预览，若没有图纸预览就没有图纸。
4. 未经权益所有人同意不得将文件中的内容挪作商业或盈利用途。
5. 众赏文库仅提供信息存储空间，仅对用户上传内容的表现方式做保护处理，对用户上传分享的文档内容本身不做任何修改或编辑，并不能对任何下载内容负责。
6. 下载文件中如有侵权或不适当内容，请与我们联系，我们立即纠正。
7. 本站不保证下载资源的准确性、安全性和完整性, 同时也不承担用户因使用这些下载资源对自己和他人造成任何形式的伤害或损失。

数值分析课程设计---线性方程组求解

文档简介

温馨提示

最新文档

评论

数值分析课程设计---线性方程组求解

文档简介

温馨提示

最新文档

评论

免费下载