c语言编程求解线性方程组论文
线性方程组的数值算法C语言实现(附代码)
线性方程组AX=B 的数值计算方法实验一、 实验描述：随着科学技术的发展，线性代数作为高等数学的一个重要组成部分，在科学实践中得到广泛的应用。
本实验的通过C 语言的算法设计以及编程，来实现高斯消元法、三角分解法和解线性方程组的迭代法（雅可比迭代法和高斯-赛德尔迭代法），对指定方程组进行求解。
二、 实验原理：1、高斯消去法：运用高斯消去法解方程组，通常会用到初等变换，以此来得到与原系数矩阵等价的系数矩阵，达到消元的目的。
初等变换有三种：(a)、(交换变换)对调方程组两行；(b)、用非零常数乘以方程组的某一行；(c)、将方程组的某一行乘以一个非零常数，再加到另一行。
通常利用(c)，即用一个方程乘以一个常数，再减去另一个方程来置换另一个方程。
在方程组的增广矩阵中用类似的变换，可以化简系数矩阵，求出其中一个解，然后利用回代法，就可以解出所有的解。
2、选主元：若在解方程组过程中，系数矩阵上的对角元素为零的话，会导致解出的结果不正确。
所以在解方程组过程中要避免此种情况的出现，这就需要选择行的判定条件。
经过行变换，使矩阵对角元素均不为零。
这个过程称为选主元。
选主元分平凡选主元和偏序选主元两种。
平凡选主元：如果()0p pp a ≠，不交换行；如果()0p pp a =，寻找第p 行下满足()0p pp a ≠的第一行，设行数为k ，然后交换第k 行和第p 行。
这样新主元就是非零主元。
偏序选主元：为了减小误差的传播，偏序选主元策略首先检查位于主对角线或主对角线下方第p 列的所有元素，确定行k ，它的元素绝对值最大。
然后如果k p >，则交换第k 行和第p 行。
通常用偏序选主元，可以减小计算误差。
3、三角分解法：由于求解上三角或下三角线性方程组很容易所以在解线性方程组时，可将系数矩阵分解为下三角矩阵和上三角矩阵。
其中下三角矩阵的主对角线为1，上三角矩阵的对角线元素非零。
有如下定理：如果非奇异矩阵A 可表示为下三角矩阵L 和上三角矩阵U 的乘积： A LU = (1) 则A 存在一个三角分解。
线性方程组的数值算法C语言实现(附代码)
线性方程组AX=B 的数值计算方法实验一、 实验描述：随着科学技术的发展，线性代数作为高等数学的一个重要组成部分，在科学实践中得到广泛的应用。
本实验的通过C 语言的算法设计以及编程，来实现高斯消元法、三角分解法和解线性方程组的迭代法（雅可比迭代法和高斯-赛德尔迭代法），对指定方程组进行求解。
二、 实验原理：1、高斯消去法：运用高斯消去法解方程组，通常会用到初等变换，以此来得到与原系数矩阵等价的系数矩阵，达到消元的目的。
初等变换有三种：(a)、(交换变换)对调方程组两行；(b)、用非零常数乘以方程组的某一行；(c)、将方程组的某一行乘以一个非零常数，再加到另一行。
通常利用(c)，即用一个方程乘以一个常数，再减去另一个方程来置换另一个方程。
在方程组的增广矩阵中用类似的变换，可以化简系数矩阵，求出其中一个解，然后利用回代法，就可以解出所有的解。
2、选主元：若在解方程组过程中，系数矩阵上的对角元素为零的话，会导致解出的结果不正确。
所以在解方程组过程中要避免此种情况的出现，这就需要选择行的判定条件。
经过行变换，使矩阵对角元素均不为零。
这个过程称为选主元。
选主元分平凡选主元和偏序选主元两种。
平凡选主元：如果()0p pp a ≠，不交换行；如果()0p pp a =，寻找第p 行下满足()0p pp a ≠的第一行，设行数为k ，然后交换第k 行和第p 行。
这样新主元就是非零主元。
偏序选主元：为了减小误差的传播，偏序选主元策略首先检查位于主对角线或主对角线下方第p 列的所有元素，确定行k ，它的元素绝对值最大。
然后如果k p >，则交换第k 行和第p 行。
通常用偏序选主元，可以减小计算误差。
3、三角分解法：由于求解上三角或下三角线性方程组很容易所以在解线性方程组时，可将系数矩阵分解为下三角矩阵和上三角矩阵。
其中下三角矩阵的主对角线为1，上三角矩阵的对角线元素非零。
有如下定理：如果非奇异矩阵A 可表示为下三角矩阵L 和上三角矩阵U 的乘积： A LU = (1) 则A 存在一个三角分解。
C语言LU分解法实现解线性方程组
C语言LU分解法实现解线性方程组C语言LU分解法实现解线性方程组#include#include//LU分解法实现解线性方程组double sumU(double L[5][5] ,double U[5][5], int i, int j ){ double sU = 0.0;for (int k = 1; k <= i-1 ; k++){sU += L[i-1][k-1] * U[k-1][j-1];}return sU;}//计算求和1double sumL(double L[5][5] ,double U[5][5], int i, int j ){ double sL = 0.0;for (int k = 0; k <= j-1; k++){sL += L[i-1][k-1] * U[k-1][j-1];}return sL;}//计算求和2double sumY(double L[5][5] ,double y[5],int i){double sY=0.0;for (int k = 1; k <= i - 1; k++){sY += L[i-1][k-1] * y[k-1];}return sY;}//计算求和3double sumX(double U[5][5] ,double x[5],int i ,int m){double sX = 0.0;for (int k = i+1; k <= m; k++){sX += U[i-1][k-1] * x[k-1];}return sX;}//计算求和4int main(){double a[5][5] = {4,5.3,-5.6,-3,-3.4,5,-2.1,3.2,4,-8,2,-4,-7.2,-5,-2.4,5,-3,-8,2.3,3,4.2,-3,0,0,-2};//将系数存入二维数组double L[5][5] = {0};double U[5][5] = {0};//初始化部分double b[5] = {100.16,-75.72,98.2,57.1,3.72};int n = 5;//n阶//输出[Ab]printf("[A]:\n");for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++){printf("%f\t", a[i-1][j-1]);}printf("\n");}//计算L,Ufor (int i = 1; i <= n; i++){L[i-1][i-1] = 1;//对角线元素为1for (int j = i; j <= n; j++)//由于数组下标从0开始所以i-1,j-1U[i-1][j-1] = a[i-1][j-1] - sumU(L,U,i,j);if(j+1 <= n) L[j][i-1] = (a[j][i-1] - sumL(L,U,j+1,i))/U[i-1][i-1];//i变j+1，j变i }}//输出Uprintf("U:\n");for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++){printf("%f\t",U[i-1][j-1]);}printf("\n");}//输出Lprintf("L:\n");for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++){printf("%f\t",L[i-1][j-1]);}printf("\n");}//由Ly=b 求ydouble y[5] = {0.0};y[0] = b[0];//y(1) = b(1);for (int i = 2; i <= n; i++)y[i-1] = b[i-1] - sumY(L,y,i);}//由Ux=y 求xdouble x[5] = {0.0};for (int i = n; i >= 1; i--){x[i-1] =( y[i-1] - sumX(U,x,i,n))/ U[i-1][i-1]; } //输出yprintf("y:\n");for (int i = 0; i < n; i++){printf("%f\n",y[i]);}printf("\n");//输出xprintf("x:\n");for (int i = 0; i < n; i++){printf("%f\n",x[i]);}printf("\n");system("pause");return 0;}。
线性方程组求解.cpp
#include <stdio.h>#include <math.h>#include <stdlib.h>#define MAX 20 //定义最大的方程组中方程个数double a[MAX+1][MAX+2] ; //方程组系数存放的增广矩阵存放数组double b[MAX+1][MAX+2] ;int n ; //方程的实际个数int xxx = 0; //是否初始化void init()//输入线性方程组{xxx= 1;printf("\n\t请输入方程组的方程个数: ");scanf ("%d",&n);if( n > MAX )//输入的数超过了定义的最大方程个数，退出{printf("sorry,can not deal !\n\n");printf("最大能处理的方程组为%d阶方程组\n\n,MAX");exit(0);}printf("\n请依次输入方程组的方程的系数(顺序从上到下，从左至右)：\n"); for(int i = 1 ; i < n+1 ; i++ )//n行n+1列的增广矩阵for(int j = 1 ; j < n+2 ; j++ )scanf ("%lf",&a[i][j]);for(int i = 1 ; i < n+1 ; i++ ) //备份for(int j = 1 ; j < n+2 ; j++ )b[i][j]=a[i][j];}void reset()//将数组a还原成初始状态{for(int i = 1 ; i < n+1 ; i++ )for(int j = 1 ; j < n+2 ; j++ )a[i][j]=b[i][j];}void display()//输出增光矩阵{for(int i = 1 ; i < n+1 ; i++ ){for(int j = 1 ; j < n+2 ; j++ )printf("%.3f ",a[i][j]);printf("\n");}}void print()//输出线性方程组{int count=0;//记录某一行中系数为0的个数for(int i = 1 ; i < n+1 ; i++ )for(int j = 1 ; j < n+2 ; j++ ){if( a[i][j] == 0 && j != n+1)count ++ ;else{if( j == 1 || count == j-1)//系数为第一项或者该项之前的所有项的系数都是0printf ("%.3f X%d ",a[i][j],j);//小数后面保留三位elseif( j == n+1 ){printf(" = %.3f\n",a[i][n+1]);count =0;}elsea[i][j]>0 ? printf (" + %.3f X%d ",fabs(a[i][j]),j): printf (" - %.3f X%d ",fabs(a[i][j]),j);}}}void selectMainEle(int k)//选取第k列的主元{double mainEle = fabs(a[k][k]) ,temp=0;int j = k ;//用变量j记住主元初始位置for(int i = k+1 ; i < n+1 ; i++ )//选出绝对值最大的数if( mainEle < fabs(a[i][k])){mainEle = fabs(a[i][k]) ;j = i; //j记录主元（列中的最大数）的行数}if( k != j ) //初始值不是最大值，k,j换行for(int i = 1 ; i < n+2 ; i++ ){temp = a[k][i] ;a[k][i] = a[j][i] ;a[j][i] = temp ;}}void printit()//输出方程组的根{printf("\n\n求解的方程组的根为：\n");for(int i=1;i<n+1;i++){if(i%4==0) printf("\n");//每一行输出三个解 printf("X%d=%.3f ",i,a[i][n+1]);}printf("\n");}void gause()//高斯列主消元法核心{printf("线性方程组为：\n");print();//输出输入的方程组for( int k=1 ; k < n ; k ++)//消元过程{selectMainEle(k);for(int i = k+1 ; i < n+1 ; i++ )a[i][k] /= a[k][k];for(int i = k+1 ; i < n+1 ; i++ )for(int j = k+1 ; j < n+2 ; j++ )a[i][j] -= a[i][k] * a[k][j] ;printf("\n消元过程如下：\n");for(int i=1;i<n+1;i++){for(int j=1;j<n+1;j++)if(j<k+1&&i>j)printf("%.4f ",0.0);elseprintf("%.4f ",a[i][j]);printf("\n");}}a[n][n+1] /= a[n][n] ;//回代过程for(int i=n-1 ; i>0 ; i--){double sum=0.0;for(int j=i+1 ;j<n+1 ;j++)sum += a[i][j] * a[j][n+1];a[i][n+1] = (a[i][n+1] - sum)/a[i][i];}printit();}void gauseyuedang()//高斯-约当列主元消去法，高斯列主元消去法的改进{printf("线性方程组为：\n");print();//输出输入的方程组double temp;for( int k=1 ; k < n+1 ; k++)//消元，只保留主元{selectMainEle(k);temp = a[k][k];//用temp记住主元的值for(int i=k ; i < n+2 ; i++)//将主元变为1a[k][i] /= temp;//开始消元，出去主元第k列元素全部消去变为零for(int i = 1 ; i < n+1 ; i++ )//行控制if( i != k ) //行变换不包括当前主元所在行for(int j = k+1 ; j < n+2 ; j++ )//列控制a[i][j]=a[i][j]-a[k][j]*a[i][k];printf("\n消元过程如下：\n");for(int i=1;i<n+1;i++){for(int j=1;j<n+1;j++)if(j<k+1&&i!=j)printf("%.4f ",0.0);elseprintf("%.4f ",a[i][j]);printf("\n");}}printit();//输出方程组的解}void LU()//LU分解法{double sum ;printf("线性方程组为：\n");print();//输出输入的方程组for(int i=2;i<n+1;i++)a[i][1] /= a[1][1];for(int r=2 ; r<n+1 ; r++){for(int i=r ; i<n+1 ; i++)//U变换{sum = 0;for(int k=1;k<r;k++)sum += a[r][k]*a[k][i];a[r][i] -= sum;}for(int i=r+1 ; i<n+1 ; i++)//L变换{sum = 0;for(int k=1 ; k<r ; k++)sum += a[i][k]*a[k][r];a[i][r] = (a[i][r] - sum)/a[r][r];}}printf("\n\nLU分解中的L为：\n");for(int i=1 ; i < n+1 ; i++){for(int j=1 ;j < n+1 ; j++)if(i < j) //上部为0printf("%.3f ",0.0);elsei==j ? printf("%.3f ",1.0): printf("%.3f ",a[i][j]); //主对角线为1 printf("\n");}printf("\n\nLU分解中的U为：\n");for(int i=1 ; i < n+1 ; i++){for(int j=1 ;j < n+1 ; j++)if(i > j) //上部为0printf("%.3f ",0.0);elseprintf("%.3f ",a[i][j]);printf("\n");}for(int i=2;i<n+1;i++)//第一次回带求解{sum=0;for(int k=1;k<i;k++)sum+=a[i][k]*a[k][n+1];a[i][n+1] -= sum;}printf("\n\n第一次求解的方程组(LY=b)的根为：\n");for(int i=1;i<n+1;i++){if(i%4==0) printf("\n");//每一行输出三个解printf("Y%d=%.3f ",i,a[i][n+1]);}a[n][n+1]/=a[n][n];//Xn的值for(int i=n-1;i>0;i--){sum=0;for(int k=i+1;k<n+1;k++)sum+=a[i][k]*a[k][n+1];a[i][n+1] = (a[i][n+1] - sum)/a[i][i];}printf("\n\n第二次求解的方程组(UX=y)的根，即原方程组的解为：\n"); for(int i=1;i<n+1;i++){if(i%4==0) printf("\n");//每一行输出三个解printf("X%d=%.3f ",i,a[i][n+1]);}printf("\n");}void Jacobi()//雅可比迭代法{printf("线性方程组为：\n");print();//输出输入的方程组int count=0;///迭代次数double latest[n+1],old[n+1],temp[n+1],sum,precision,max,temp2;for(int i=1;i<n+1;i++)if(a[i][i] == 0){printf("sorry，主对角线中有数据为0，不能用Jacobi迭代法处理！\n请返回重新选择");return ;}printf("\n输入求解精度值: ");scanf("%lf",&precision);for(int i=1 ; i < n+1 ; i++) //初始状态解为0{latest[i] = 0.0;//新值，下一次迭代结果old[i] = 0.0;//旧值，上一次的迭代结果}printf("Jacobi迭代法迭代过程如下:\n");do{ max =0;printf("\n\n第%d次迭代的结果: ",count++);for(int i=1 ; i<n+1 ; i++){if(i%4==0) printf("\n");//每一行输出三个解printf("X%d=%.4f ",i,old[i]);}for(int i = 1 ; i < n+1 ; i++)//迭代过程,完成新的一组解{sum =0.0;for(int j = 1 ; j < n+1 ; j++)if(j != i) sum = sum + a[i][j] * old[j];latest[i]=(a[i][n+1] - sum)/a[i][i];temp[i] = latest[i];//Y用来记录本次迭代的值temp2 = fabs(latest[i] - old[i]); //新值减旧值if(max < temp2) max = temp2 ;}printf("最大的偏差为：%.4f\n",max);for(int i=1 ; i<n+1 ; i++)old[i] = temp[i]; //将新值保留到old数组} while( max > precision && count <= 100);//前后两次解的偏差满足精度要求或者迭代次数超过100次printf("\n\n第%d次(最后的)求解的方程组的根为：\n",count);for(int i=1;i<n+1;i++){if(i%4==0) printf("\n");//每一行输出三个解printf("X%d=%.4f ",i,old[i]);}printf("\n");}void GS()//高斯-赛德尔迭代法{printf("线性方程组为：\n");print();//输出输入的方程组double precision,sum,X[n+1],max,temp,old;int count=0;///迭代次数for(int i=1;i<n+1;i++)if(a[i][i] == 0){printf("sorry，主对角线中有数据为0，不能用高斯赛德尔迭代法处理！\n请返回重新选择");return ;}printf("\n输入求解精度值: ");scanf("%lf",&precision);for(int i = 1 ; i < n+1 ; i++)// 解初始化为0X[i] = 0.0 ;printf("高斯赛德尔迭代法迭代过程如下:\n");do{printf("\n\n第%d次迭代的结果: ",count++);for(int i=1 ; i<n+1 ; i++){if(i%4==0) printf("\n");//每一行输出三个解printf("X%d=%.5f ",i,X[i]);}for(int i = 1 ; i < n+1 ; i++)//迭代过程,完成新的一组解{sum = 0.0;max = 0.0;old =X[i];for(int j = 1 ; j < n+1 ; j++)if(j != i) sum += a[i][j] * X[j] ;X[i] = (a[i][n+1] - sum) /a[i][i];temp = fabs(X[i]-old);if(max < temp) max = temp;}printf("最大的偏差为：%.5f\n",max);} while(max > precision && count <= 100);//前后两次解的偏差满足精度要求或者迭代次数超过100次printf("\n\n第%d次(最后的)求解的方程组的根为：\n",count);for(int i=1;i<n+1;i++){if(i%4==0) printf("\n");//每一行输出三个解printf("X%d=%.5f ",i,X[i]);}printf("\n");}int main(){int xz;while(1){printf("\t\t\t*****************************************\n");printf("\t\t\t**** \t 0.更改线性方程组 ****\n");printf("\t\t\t**** \t 1.高斯列主消元法 ****\n");printf("\t\t\t**** \t 2.高斯-约当列主消去法 ****\n");printf("\t\t\t**** \t 3.LU分解法 ****\n");printf("\t\t\t**** \t 4.雅各比迭代法 ****\n");printf("\t\t\t**** \t 5.高斯-赛德尔迭代法 ****\n");printf("\t\t\t**** \t 6.退出 ****\n");printf("\t\t\t*****************************************\n");printf("\t请根据相应的代号，从上述方法中选择其一： ");scanf("%d",&xz);switch(xz){case 0: init(); break;case 1: if(xxx){reset();gause();}else{printf("sorry,还没有输入线性方程组!\n");init();}break;//高斯列主消元法case 2: if(xxx){reset();gauseyuedang();}else{printf("sorry,还没有输入线性方程组!\n");init();}break;//高斯-约当列主元消去法case 3: if(xxx){reset();LU();}else{printf("sorry,还没有输入线性方程组!\n");init();}break;case 4:if(xxx){reset();Jacobi();}else{printf("sorry,还没有输入线性方程组!\n");init();}break;case 5: if(xxx){reset();GS();}else{printf("sorry,还没有输入线性方程组!\n");init();}break;case 6: exit(0);default:printf("\n\t错误输入o(︶︿︶)o 唉！\n\n");break;}system("pause");system("cls");}}。
线性方程组求解 高质量C语言程序
课题：线性方程组求解目录课题描述及要求 (2)项目分析 (2)算法流程 (2)方法说明 (3)源代码 (3)程序说明 (6)运行结果 (7)总结 (7)参考文献 (8)线性方程组求解05111114 陈龙一．课题描述和功能要求1.描述：求解线性方程组Ax=b，写成函数。
其中，A为n乘n阶矩阵，x为n元未知向量，b为n个常数组成的矩阵。
2.要求：采用高斯先列主元消元法（也可采用其他方法）求解线性方程组AX=b。
二．项目分析数学上，高斯消去法或称高斯－约当消去法，由高斯和约当得名（很多人将高斯消去作为完整的高斯－约当消去的前半部分），它是线性代数中的一个算法，用于决定线性方程组的解，决定矩阵的秩，以及决定可逆方矩阵的逆。
当用于一个矩阵时，高斯消去产生“行消去梯形形式”。
例如：一个二元一次方程组，设法对每个等式进行变形，使两个等式中的同一个未知数的系数相等，这两个等式相减，得到一个新的等式，在这个新的等式中，细数相等的未知数就被除去了（系数为0）。
同样的也适合多元多次方程组。
我们知道m*n矩阵（用大写字母表示）是一个m行n列的数阵，n维向量（用加粗的小写字母表示）是n个数的数组，也就是一个n*1矩阵（列向量。
我们不考虑行向量）。
另外，大家也都知道矩阵乘法。
因此一个m*n线性方程组可以表示为Ax=b，其中A是由系数aij组成的m*n矩阵即系数矩阵，x是n维的未知数向量，b是m维的结果向量。
如果把向量b写到A的右边得到m*(n+1)的矩阵，得到的新矩阵称为这个方程组的增广矩阵。
每一个方程组均对应于一个增广矩阵。
三．算法流程图四．方法说明（1）第1步消元——在增广矩阵（A，b）第一列中找到绝对值最大的元素，将其所在行与第一行交换（2）第2步消元——在增广矩阵（A，b）中的第二列中（从第二行开始）找到绝对值最大的元素，将其所在行与第二行交换（3）第3步消元——在增广矩阵（A，b）中的第三列中（从第三行开始）找到绝对值最大的元素，将其所在行与第二行交换（4）按x4- x3- x2- x1的顺序回代求解出方程组的解。
C++课程设计高斯消元法求线性代数方程组的解
C++课程设计高斯消元法求线性代数方程组的解第一篇：C++课程设计高斯消元法求线性代数方程组的解河北工业大学计算机软件技术基础（VC）课程设计报告学院管理班级管理104班姓名杨立宝 __ 学号 101707____ 成绩 __ ____一、题目：求线性代数方程组的解（高斯消去法）（C13）二、设计思路1、总体设计1）分析程序的功能第一：编写输入程序，通过键盘先输入对应的已知量及函数的大小n和系数a[i]和得数b[i]。
第二：编写中间程序，通过函数的调用先定义线性代数方程，然后通过程序求出方程的梯形矩阵系数，并最终得出结果。
第三编写输出程序，输出最终结果。
2）系统总体结构：设计程序的组成模块，简述各模块功能。
模块一：各函数的具体内容A：三个输入函数，分别输入n，一维数组，二维数组。
即输入已知量。
B：中间运算函数，计算是使得方程系数所成的矩阵成梯形矩阵，未知数的结果。
即计算中间变量及结果。
C：最后输出函数，输出最后计算结果。
模块二：各函数原型的声明 a写头文件。
b变量声明:存放输入数据的数组的声明，存放中间变量的数组的声明，存放运算结果的数组的声明。
分别存放对应数据。
c输入有关操作的文字d函数调用，在运算中自动调用对应的函数解决对应问题。
模块三:主函数2、各功能模块的设计：说明各功能模块的实现方法模块一：各个函数的声明，直接声明。
模块二：各函数都通过for循环来实现各个数组之间的基本运算。
3、设计中的主要困难及解决方案在这部分论述设计中遇到的主要困难及解决方案。
1）困难1 函数调用是怎么用？解决方案：仔细阅读课本，以及同学之间的讨论，和老师的帮助。
4、你所设计的程序最终完成的功能1）说明你编制的程序能完成的功能输入线性代数的系数后，运行程序即可得到梯形矩阵和结果。
2）准备的测试数据及运行结果三、程序清单如果是使用一个文件完成的程序，只需列出程序代码。
如果是使用多文件完成的程序，首先说明程序中的代码存放在哪些文件中，说明文件名（例如：本程序包含first.cpp、second.cpp、third.cpp和all.h四个文件）；然后依次给出每个文件名及该文件清单，例如：#include const N= 10;//设定矩阵大小范围 /* * 使用已经求出的x，向前计算x（供getx()调用）* double a[][] 系数矩阵 * double x[] 方程组解 * int i 解的序号 * int n 矩阵大小 * return 公式中需要的和 */ double getm(double a[N][N], double x[N], int i, int n){ double m = 0;int r;for(r=i+1;rresult = double(b[n-1]/a[n-1][n-1]);else //计算其他x值（对于公式中的求和部分，需要调用getm()函数）result = double((b[i]-getm(a,x,i,n))/a[i][i]);return result;} void main(){ //double a[N][N] = {{2},{1,3,2},{1,2,2}};//double b[N] = {4,6,5};double a[N][N];//系数矩阵 double b[N];//右端项 double x[N];//方程组解 int i,j,k;int n=N;//矩阵大小/*用户手工输入矩阵*/ cout<>n;cout<>a[i][j];} cout<>b[i];} /*显示原始矩阵*/ cout</*进行高斯消去*/ for(j=0;j/*显示处理后矩阵*/ cout</*回代方式解方程组*/ for(i=n-1;i>=0;i--){ x[i] = getx(a,b,x,i,n);} /*显示方程组解*/ cout<四、对该设计题目有何更完善的方案1、对自己完成程序进行自我评价。
关于线性方程组求解的论文
线性方程组的求解问题摘要:线性代数是代数学的一个重要组成部分，广泛应用于现代科学的许多分支。
其核心问题之一就是线性方程组的求解问题。
本文先简要介绍了线性方程组求解的历史，然后给出线性方程组解的结构。
重点介绍了解线性方程组的几种方法:消元法，克拉默法则和利用向量空间概念求解线性方程组的方法。
最后介绍了如何利用Matlab、Excel等常用电脑软件解线性方程。
关键词:线性方程组克拉默法则 Matlab1.线性方程组求解的历史线性方程组的解法，早在中国古代的数学著作《九章算术》方程章中已作了比较完整的论述。
其中所述方法实质上相当于现代的对方程组的增广矩阵施行初等行变换从而消去未知量的方法，即高斯消元法。
在西方，线性方程组的研究是在17世纪后期由莱布尼茨开创的。
他曾研究含两个未知量的三个线性方程组组成的方程组。
麦克劳林在18世纪上半叶研究了具有二、三、四个未知量的线性方程组，得到了现在称为克莱姆法则的结果。
克莱姆不久也发表了这个法则。
18世纪下半叶，法国数学家贝祖对线性方程组理论进行了一系列研究，证明了一元齐次线性方程组有非零解的条件是系数行列式等于零。
法国数学家范德蒙不仅对行列式理论本身进行了开创性研究，而且把行列式应用于解线性方程组。
英国数学家凯莱用矩阵表示线性方程组及线性方程组的解。
19世纪，英国数学家史密斯和道奇森继续研究线性方程组理论，前者引进了方程组的增广矩阵和非增广矩阵的概念，后者证明了n个未知数m个方程的方程组相容的充要条件是系数矩阵和增广矩阵的秩相同。
格拉斯曼则使用向量表示线性方程组的解。
2.线性方程组解的结构n元线性方程组的一个解(c1,c2,……c n)是一个，维向量，当方程组有无穷多个解时，需要研究这些解向量之间的关系，以便更透彻地把握住它们。
关于齐次线性方程组的解的结构有以下结论:1)定义1齐次线性方程组的一组解η1，η2……ηt称为该方程组的一个基础解系，如果a)该方程组的任一解都能表成η1，η2……ηt的线性组合。
c语言编程求解线性方程组论文
本科专业学年论文题目：线性方程组求解方法比较姓名郭凤专业计算机科学与技术专业班级08级本科（2）班指导教师刘晓娜完成日期：2010 年1月8日题目：线性方程组求解方法比较摘要目前在许多实际应用领域,诸如航空、造船以及其它结构工程中,常遇到求解大型线性代数方程组的问题。
本文根据线性代数方程组的雅可比迭代法、LU分解法及高斯列主元消去法三种解法进行了比较，用以方便在实际生活应用中更好的作出选择。
在第二章中本文详细的介绍了线性代数方程组的三种解法的理论知识与证明过程。
为了更加清晰的展现三种方法的不同点以及其各自的优越性，本文在第三章中给出了实例，通过实例的计算与程序的实现，再结合三种方法的优缺点进行了比较。
关键字：线性代数方程组、迭代法、LU分解法、高斯列主元消去法、不同点、比较目录第一章绪论 (4)第二章求解线性方程组的基本理论2.1 迭代法 (5)2.2 直接三角分解法 (6)2.3 高斯消去法 (7)第三章三种算法求解方程组实例3.1 迭代法 (8)3.2 直接三角分解法 (10)3.3 高斯列主元消去法 (14)3.4 三种方法的优缺点比较 (16)参考文献 (17)第一章绪论在自然科学、工程技术、经济和医学各领域中产生的许多实际问题都可以通过数学语言描述为数学问题，也就是说，由实际问题建立数学模型，然后应用各种数学方法和技巧来求解，最后把结果反馈到实际应用中去。
计算数学是数学学科的一大分支，它研究如何借助于计算机求解各类数值问题。
应用计算机求解各类数值问题需要经历以下几个主要过程：1、实际问题2、数学模型3、计算方法4、算法设计5、计算求解目前已有的数学软件可以帮助我们实现上机计算，基本上已经将数值分析的主要内容设计成简单的函数，只要调用这些函数进行运算便可得到数值结果。
数值分析的内通包括线性代数方程组求解、非线性代数方程（组）求解、矩阵的特征值与特征值向量的计算、函数插值、函数逼近、数值积分与数值微分以及微分方程数值解法。
解线性方程组的c程序
1.环境的概述以及对发展的影响
1.1环境的构成
环境由自然环境以及社会环境两方面构成，自然环境是社会环境的基础，而社会环境又是自然环境的发展。自然环境是人类赖以生存的物质基础，是各种自然因素的总和，社会环境是人类生存及活动范围内的社会物质、精神条件的总和，包括整个社会文化体系。
自然环境以及社会环境都对社会发展有着重要的影响，他们是发展的先决条件，亦是发展的限制条件。
3.可持续发展的意义
环境与发展是相互统一的，我们要发展，亦要追求完美的环境，浩瀚的宇宙当中，这颗蓝色的小星球十分脆弱，鉴于环境的未来，人类的未来以及地球的未来，可持续发展是必走之路。只有这样才能达到人与自然的统一，自然与发展的协调，发展和生命的延续。
结论：自然和发展是一个有机的整体，二者对人类都至关重要，将二者相互统一，走可持续发展道路是人们最好的选择亦是不得不实行的选择。只有整体协调，控制发展、维护环境，才能让发展真正的持久。
2.可持续发展道路
面对越来越严重的环境问题，人们必须选择一条既可维护自然环境又可保证发展的可持续发展道路，可持续发展道路可持续发展即是满足当代人的需要，又不对后代人满足其需要的能力构成危害的发展。
可持续发展依然突出强调发展的主题，以自然资源为基础，同环境承载能力相协调，讲究生态效益。可持续发展的实施以适宜的政策和法律体系为条件，承认自然环境的价值，认为发展与环境是一个有机整体。
导言：20世纪中叶，在面对着经济飞速发展的同时，人口问题、大气问题、海洋污染、生物多样性消失、生态环境等问题日益恶劣，可持续发展思想进入人们研究以及实施范围。1972年，联合国确定世界环境日，1992年，联合国环境与发展大会发表了《里约热内卢环境与发展宣言》、《21世纪议程》、《生物多样性公约》等，环境问题成了世界性首要问题。各个国家开始实行可持续发展道路，从人口、资源、环境以及稳定四个方面战略性的部署，以求环境与发展的协调。
毕业设计论文 高斯消去法求解线性方程组
摘要高斯消去法是求解线性方程组的最基本的方法之一。
为了充分利用GPU (Graphics Processing Unit，图形处理器)的并行处理能力，本文改进了高斯列主元消去法的实现过程，从而提高了求解线性方程组的速度。
并研究了在不同方程组阶数下，GPU对这此算法的加速效果。
NVIDIA新近推出的GPU计算平台采用矩阵型的计算架构，对处理大型矩阵具有极大的优势，且相对CPU有着更高的算法可并行性和计算效率。
本文力图基于GPU的CUDA开发环境，利用GP-GPU的计算特性实现求解线性方程组，以提高算法的运行效率。
最后，本文用C语言实现了高斯列主元消去算法求解线性方程组的基本过程，并分别在NVIDIA GPU并行计算平台和Intel CPU计算平台上加以运行，同时进行了两种计算平台上算法实现的性能比较。
关键词：求解线性方程组；高斯消去法；GPU；CUDA；并行计算AbstractGaussian elimination method is one of the most basic methods for solving linear equations. In order to take full advantage of GPU (Graphics Processing Unit, GPU) of the parallel processing capability, this paper improved Gaussian PCA out of the realization of the process of elimination, resulting in improved system of linear equations to solve the speed. And studied the different equations in a few bands, GPU accelerated the effect of this algorithm. NVIDIA recently introduced the use of GPU computing platform for the calculation of matrix-type structure, to deal with large-scale matrix has great advantages, and the relative CPU algorithm has higher computational efficiency and parallelism. This article seeks to CUDA for GPU-based development environment, the use of GP-GPU computing features to achieve the solution of linear equations in order to improve the effi ciency of algorithm. Finally, using C language realization of the Gaussian elimination algorithm PCA out of linear equations to solve the basic process and NVIDIA GPU in parallel computing platform and Intel CPU computing platform to be run, at the same time on two types of computing platforms algorithm Performance Comparison of the achievement.Key words:Solving linear equations; Gaussian elimination method; GPU; CUDA; Parallel Computing目录第一章绪论 (1)1.1 引言 (1)1.2 论文研究背景 (1)1.3 论文研究的目的和意义 (2)1.4 论文结构安排 (3)第二章求解线性方程组的基本理论 (4)2.1 高斯－约当消去法 (4)2.2 矩阵三角分解法 (5)直接三角分解法 (5)追赶法 (5)2.3 平方根法 (6)2.4 迭代法 (6)2.5 高斯消去法 (7)2.6 高斯列主元素消去法 (9)第三章NVIDIA CUDA并行计算平台 (11)3.1 GPU 技术简介 (11)3.2 CUDA介绍 (13)3.3 CUDA编程模型 (17)3.4 应用程序接口 (20)编程语言扩展 (20)第四章功能实现和相关函数介绍 (22)4.1 程序在CPU上的实现 (22)高斯列主元消去算法实现过程 (22)各文件中的主要功能函数介绍 (24)4.2 程序在GPU上的实现 (26)文件中C语言的扩展 (26)文件编写过程 (29)并行性实现 (31)4.3性能比较与结果分析 (32)第五章总结与展望 (36)致谢 (37)参考文献 (38)第一章绪论1.1 引言当今很多科学与工程计算问题大都可以化为线性代数方程组的形式，所以有效的求解线性方程组在科学和工程计算中是非常重要的。
线性方程组的数值算法C语言实现
线性方程组的数值算法C语言实现一、高斯消元法高斯消元法是一种求解线性方程组的常用方法。
它的基本思想是通过行变换和列变换，将方程组化为上三角矩阵，然后再通过回代法求解。
以下是高斯消元法的C语言实现代码：```c#include<stdio.h>#define N 3 // 设置方程个数//高斯消元法函数void gauss_elimination(float a[N][N+1])int i, j, k;//消元for(k=0; k<N-1; k++)for(i=k+1; i<N; i++)float factor = a[i][k] / a[k][k];for(j=k; j<N+1; j++)a[i][j] -= a[k][j] * factor;}}}//回代float x[N];for(i=N-1; i>=0; i--)x[i]=a[i][N]/a[i][i];for(j=i-1; j>=0; j--)a[j][N]-=a[j][i]*x[i];}}//输出结果for(i=0; i<N; i++)printf("x[%d] = %f\n", i+1, x[i]);}int mainfloat a[N][N+1];//输入方程组系数矩阵printf("请输入方程组的系数矩阵：\n"); for(int i=0; i<N; i++)for(int j=0; j<=N; j++)scanf("%f", &a[i][j]);}}//调用高斯消元法函数gauss_elimination(a);return 0;```以上代码通过用户输入方程组的系数矩阵，然后调用`gauss_elimination`函数进行高斯消元法求解，最后输出结果。
需要注意的是，该代码中假设输入的方程个数是3个，可以根据实际情况进行调整。
C语言LU分解法实现解线性方程组
C语言LU分解法实现解线性方程组LU分解法是一种常用于解线性方程组的方法。
在C语言中，可以通过编写相应的函数来实现这一方法。
首先，我们需要定义一个函数来进行LU分解。
LU分解将一个矩阵分解为一个下三角矩阵L和一个上三角矩阵U的乘积。
下面是一个示例函数实现：```cfor (int i = 0; i < n; i++)for (int k = i; k < n; k++)double sum = 0;for (int j = 0; j < i; j++)sum += L[i][j] * U[j][k];}U[i][k] = A[i][k] - sum;}for (int k = i; k < n; k++)if (i == k)L[i][i]=1;} elsefor (int j = 0; j < i; j++)sum += L[k][j] * U[j][i];}L[k][i] = (A[k][i] - sum) / U[i][i];}}}```上述函数中，A是输入的矩阵，n是矩阵的维度，L和U是输出的下三角矩阵和上三角矩阵。
接下来，我们可以定义一个函数来解线性方程组。
利用LU分解后的矩阵L和U，我们可以通过两次前代和回代来求解线性方程组。
下面是一个示例函数实现：```cvoid solveLU(double **L, double **U, double *b, double *x, int n)double *y = malloc(n * sizeof(double));// Solve Ly = b using forward substitutionfor (int i = 0; i < n; i++)for (int j = 0; j < i; j++)sum += L[i][j] * y[j];}y[i] = b[i] - sum;}// Solve Ux = y using backward substitutionfor (int i = n - 1; i >= 0; i--)double sum = 0;for (int j = i + 1; j < n; j++)sum += U[i][j] * x[j];}x[i] = (y[i] - sum) / U[i][i];}free(y);```上述函数中，L和U是LU分解后的下三角矩阵和上三角矩阵，b是线性方程组的右侧向量，x是待求解的变量向量，n是矩阵的维度。
c--解线性方程组的几种方法
//解线性方程组#include<iostream.h>#include<iomanip.h>#include<stdlib.h>//----------------------------------------------全局变量定义区const int Number=15; //方程最大个数double a[Number][Number],b[Number],copy_a[Number][Number],copy_b[Number];//系数行列式int A_y[Number]; //a[][]中随着横坐标增加列坐标的排列顺序,如a[0][0],a[1][2],a[2][1]...则A_y[]={0,2,1...};int lenth,copy_lenth; //方程的个数double a_sum; //计算行列式的值char * x; //未知量a,b,c的载体//----------------------------------------------函数声明区void input(); //输入方程组void print_menu(); //打印主菜单int choose (); //输入选择void cramer(); //Cramer算法解方程组void gauss_row(); //Gauss列主元解方程组void guass_all(); //Gauss全主元解方程组void Doolittle(); //用Doolittle算法解方程组int Doolittle_check(double a[][Number],double b[Number]); //判断是否行列式>0,若是,调整为顺序主子式全>0void xiaoqu_u_l(); //将行列式Doolittle分解void calculate_u_l(); //计算Doolittle结果double & calculate_A(int n,int m); //计算行列式double quanpailie_A(); //根据列坐标的排列计算的值,如A_y[]={0,2,1},得sum=a[0][ A_y[0] ] * a[1][ A_y[1] ] * a[2][ A_y[2] ]=a[0][0]*a[1][2]*a[2][1];void exchange(int m,int i); //交换A_y[m],A_y[i]void exchange_lie(int j); //交换a[][j]与b[];void exchange_hang(int m,int n); //分别交换a[][]和b[]中的m与n 两行void gauss_row_xiaoqu(); //Gauss列主元消去法void gauss_all_xiaoqu(); //Gauss全主元消去法void gauss_calculate(); //根据Gauss消去法结果计算未知量的值void exchange_a_lie(int m,int n); //交换a[][]中的m和n列void exchange_x(int m,int n); //交换x[]中的x[m]和x[n]void recovery(); //恢复数据//主函数void main(){int flag=1;input(); //输入方程while(flag){print_menu(); //打印主菜单flag=choose(); //选择解答方式}}//函数定义区void print_menu(){system("cls");cout<<"------------方程系数和常数矩阵表示如下:\n";for(int j=0;j<lenth;j++)cout<<"系数"<<j+1<<" ";cout<<"\t常数";cout<<endl;for(int i=0;i<lenth;i++){for(j=0;j<lenth;j++)cout<<setw(8)<<setiosflags(ios::left)<<a[i][j];cout<<"\t"<<b[i]<<endl;}cout<<"-----------请选择方程解答的方案----------";cout<<"\n 1. 克拉默(Cramer)法则";cout<<"\n 2. Gauss列主元消去法";cout<<"\n 3. Gauss全主元消去法";cout<<"\n 4. Doolittle分解法";cout<<"\n 5. 退出";cout<<"\n 输入你的选择:";}void input(){ int i,j;cout<<"方程的个数:";cin>>lenth;if(lenth>Number){cout<<"It is too big.\n";return;}x=new char[lenth];for(i=0;i<lenth;i++)x[i]='a'+i;//输入方程矩阵//提示如何输入cout<<"====================================================\n";cout<<"请在每个方程里输入"<<lenth<<"系数和一个常数:\n";cout<<"例：\n方程:a";for(i=1;i<lenth;i++){cout<<"+"<<i+1<<x[i];}cout<<"=10\n";cout<<"应输入:";for(i=0;i<lenth;i++)cout<<i+1<<" ";cout<<"10\n";cout<<"==============================\n";//输入每个方程for(i=0;i<lenth;i++){cout<<"输入方程"<<i+1<<":";for(j=0;j<lenth;j++)cin>>a[i][j];cin>>b[i];}//备份数据for(i=0;i<lenth;i++)for(j=0;j<lenth;j++)copy_a[i][j]=a[i][j];for(i=0;i<lenth;i++)copy_b[i]=b[i];copy_lenth=lenth;}//输入选择int choose(){int choice;char ch;cin>>choice;switch(choice){case 1:cramer();break;case 2:gauss_row();break;case 3:guass_all();break;case 4:Doolittle();break;case 5:return 0;default:cout<<"输入错误,请重新输入:";choose();break;}cout<<"\n是否换种方法求解(Y/N):";cin>>ch;if(ch=='n'||ch=='N') return 0;recovery();cout<<"\n\n\n";return 1;}//用克拉默法则求解方程.void cramer(){int i,j;double sum,sum_x;char ch;//令第i行的列坐标为icout<<"用克拉默(Cramer)法则结果如下:\n";for(i=0;i<lenth;i++)A_y[i]=i;sum=calculate_A(lenth,0);if(sum!=0){cout<<"系数行列式不为零,方程有唯一的解:";for(i=0;i<lenth;i++){ ch='a'+i;a_sum=0;for(j=0;j<lenth;j++)A_y[j]=j;exchange_lie(i);sum_x=calculate_A(lenth,0);cout<<endl<<ch<<"="<<sum_x/sum;exchange_lie(i);}}else{cout<<"系数行列式等于零,方程没有唯一的解.";}cout<<"\n";}double & calculate_A(int n,int m) //计算行列式{ int i;if(n==1) {a_sum+= quanpailie_A();}else{for(i=0;i<n;i++){ exchange(m,m+i);calculate_A(n-1,m+1);exchange(m,m+i);}}return a_sum;}double quanpailie_A() //计算行列式中一种全排列的值{int i,j,l;double sum=0,p;for(i=0,l=0;i<lenth;i++)for(j=0;A_y[j]!=i&&j<lenth;j++)if(A_y[j]>i) l++;for(p=1,i=0;i<lenth;i++)p*=a[i][A_y[i]];sum+=p*((l%2==0)?(1):(-1));return sum;}//高斯列主元排列求解方程void gauss_row(){int i,j;gauss_row_xiaoqu(); //用高斯列主元消区法将系数矩阵变成一个上三角矩阵for(i=0;i<lenth;i++){for(j=0;j<lenth;j++)cout<<setw(10)<<setprecision(5)<<a[i][j];cout<<setw(10)<<b[i]<<endl;}if(a[lenth-1][lenth-1]!=0){cout<<"系数行列式不为零,方程有唯一的解：\n";gauss_calculate();for(i=0;i<lenth;i++) //输出结果{cout<<x[i]<<"="<<b[i]<<"\n";}}elsecout<<"系数行列式等于零,方程没有唯一的解.\n";}void gauss_row_xiaoqu() //高斯列主元消去法{int i,j,k,maxi;double lik;cout<<"用Gauss列主元消去法结果如下:\n";for(k=0;k<lenth-1;k++){j=k;for(maxi=i=k;i<lenth;i++)if(a[i][j]>a[maxi][j]) maxi=i;if(maxi!=k)exchange_hang(k,maxi);//for(i=k+1;i<lenth;i++){lik=a[i][k]/a[k][k];for(j=k;j<lenth;j++)a[i][j]=a[i][j]-a[k][j]*lik;b[i]=b[i]-b[k]*lik;}}}//高斯全主元排列求解方程void guass_all(){int i,j;gauss_all_xiaoqu();for(i=0;i<lenth;i++){for(j=0;j<lenth;j++)cout<<setw(10)<<setprecision(5)<<a[i][j];cout<<setw(10)<<b[i]<<endl;}if(a[lenth-1][lenth-1]!=0){cout<<"系数行列式不为零,方程有唯一的解：\n";gauss_calculate();for(i=0;i<lenth;i++) //输出结果{for(j=0;x[j]!='a'+i&&j<lenth;j++);cout<<x[j]<<"="<<b[j]<<endl;}}elsecout<<"系数行列式等于零,方程没有唯一的解.\n"; }void gauss_all_xiaoqu() //Gauss全主元消去法{int i,j,k,maxi,maxj;double lik;cout<<"用Gauss全主元消去法结果如下:\n";for(k=0;k<lenth-1;k++){for(maxi=maxj=i=k;i<lenth;i++){for(j=k;j<lenth;j++)if(a[i][j]>a[maxi][ maxj]){ maxi=i;maxj=j;}}if(maxi!=k)exchange_hang(k,maxi);if(maxj!=k){exchange_a_lie(maxj,k); //交换两列exchange_x(maxj,k);}for(i=k+1;i<lenth;i++){lik=a[i][k]/a[k][k];for(j=k;j<lenth;j++)a[i][j]=a[i][j]-a[k][j]*lik;b[i]=b[i]-b[k]*lik;}}}void gauss_calculate() //高斯消去法以后计算未知量的结果{int i,j;double sum_ax;b[lenth-1]=b[lenth-1]/a[lenth-1][lenth-1];for(i=lenth-2;i>=0;i--){for(j=i+1,sum_ax=0;j<lenth;j++)sum_ax+=a[i][j]*b[j];b[i]=(b[i]-sum_ax)/a[i][i];}}void Doolittle() //Doolittle消去法计算方程组{double temp_a[Number][Number],temp_b[Number];int i,j,flag;for(i=0;i<lenth;i++)for(j=0;j<lenth;j++)temp_a[i][j]=a[i][j];flag=Doolittle_check(temp_a,temp_b);if(flag==0) cout<<"\n行列式为零.无法用Doolittle求解.";xiaoqu_u_l();calculate_u_l();cout<<"用Doolittle方法求得结果如下:\n";for(i=0;i<lenth;i++) //输出结果{for(j=0;x[j]!='a'+i&&j<lenth;j++);cout<<x[j]<<"="<<b[j]<<endl;}}void calculate_u_l() //计算Doolittle结果{ int i,j;double sum_ax=0;for(i=0;i<lenth;i++){for(j=0,sum_ax=0;j<i;j++)sum_ax+=a[i][j]*b[j];b[i]=b[i]-sum_ax;}for(i=lenth-1;i>=0;i--){for(j=i+1,sum_ax=0;j<lenth;j++)sum_ax+=a[i][j]*b[j];b[i]=(b[i]-sum_ax)/a[i][i];}}void xiaoqu_u_l() //将行列式按Doolittle分解{ int i,j,n,k;double temp;for(i=1,j=0;i<lenth;i++)a[i][j]=a[i][j]/a[0][0];for(n=1;n<lenth;n++){ //求第n+1层的上三角矩阵部分即Ufor(j=n;j<lenth;j++){ for(k=0,temp=0;k<n;k++)temp+=a[n][k]*a[k][j];a[n][j]-=temp;}for(i=n+1;i<lenth;i++) //求第n+1层的下三角矩阵部分即L{ for(k=0,temp=0;k<n;k++)temp+=a[i][k]*a[k][n];a[i][n]=(a[i][n]-temp)/a[n][n];}}}int Doolittle_check(double temp_a[][Number],double temp_b[Number]) //若行列式不为零,将系数矩阵调整为顺序主子式大于零{int i,j,k,maxi;double lik,temp;for(k=0;k<lenth-1;k++){j=k;for(maxi=i=k;i<lenth;i++)if(temp_a[i][j]>temp_a[maxi][j]) maxi=i;if(maxi!=k){ exchange_hang(k,maxi);for(j=0;j<lenth;j++){ temp=temp_a[k][j];temp_a[k][j]=temp_a[maxi][j];temp_a[maxi][j]=temp;}}for(i=k+1;i<lenth;i++){lik=temp_a[i][k]/temp_a[k][k];for(j=k;j<lenth;j++)temp_a[i][j]=temp_a[i][j]-temp_a[k][j]*lik;temp_b[i]=temp_b[i]-temp_b[k]*lik;}}if(temp_a[lenth-1][lenth-1]==0) return 0;return 1;}void exchange_hang(int m,int n) //交换a[][]中和b[]两行{int j; double temp;for(j=0;j<lenth;j++){ temp=a[m][j];a[m][j]=a[n][j];a[n][j]=temp;}temp=b[m];b[m]=b[n];b[n]=temp;}void exchange(int m,int i) //交换A_y[m],A_y[i]{ int temp;temp=A_y[m];A_y[m]=A_y[i];A_y[i]=temp;}void exchange_lie(int j) //交换未知量b[]和第i列{ double temp;int i;for(i=0;i<lenth;i++){ temp=a[i][j];a[i][j]=b[i];b[i]=temp;}}void exchange_a_lie(int m,int n) //交换a[]中的两列{ double temp;int i;for(i=0;i<lenth;i++){ temp=a[i][m];a[i][m]=a[i][n];a[i][n]=temp;}}void exchange_x(int m,int n) //交换未知量x[m]与x[n]{ char temp;temp=x[m];x[m]=x[n];x[n]=temp;}void recovery() //用其中一种方法求解后恢复数据以便用其他方法求解{for(int i=0;i<lenth;i++)for(int j=0;j<lenth;j++)a[i][j]=copy_a[i][j];for(i=0;i<lenth;i++)b[i]=copy_b[i];for(i=0;i<lenth;i++)x[i]='a'+i;a_sum=0;lenth=copy_lenth;}（注：可编辑下载，若有不当之处，请指正，谢谢!）。
线性方程组的数值解法及其计算机实现
线性方程组的数值解法及其计算机实现大连大学DALIAN UNIVERSITY2014届毕业论文（设计）题目名称：线性方程组的数值解法及其计算机实现所在学院：信息工程学院专业（班级）：信息与计算科学10级1班学生姓名：李国庆指导教师：董学东评阅人：于万波院长：裴炳南线性方程组的数值解法及其计算机实现总计：毕业论文 43 页表格 0 表插图 11 幅指导老师：董学东（教授）评阅人：于万波完成日期：2014年 5 月 21日摘要现在在工程技术、自然和社会科学中常常会碰到许多问题，比如用最小二乘法来拟合实验数据的曲线、电学中相关的网络题目、计算建筑与机器中的策划问题以及大地中的测量和经济中的投入产出问题，最后均可归纳为求解线性方程组。
因此，在解决实际问题时，求解线性方程组起着不可替代的作用。
由于在实际问题中，方程组的未知数个数多达上百个，用克莱姆法则解决起来过于麻烦，借助计算机来解决是一个非常可行而有效地方法。
本文主要研究求解线性方程组的直接解法和迭代解法这两种数值解法，并且利用Matlab编写程序来实现这些方程组的求解。
关键词：线性方程组；数值解；直接法；迭代法；MatlabABSTRACTNow in engineering, natural sciences and social sciences, many of the problems which frequently encountered can be attributed to the solution of linear equations final, such as the problems of curve fitting with experimental data for using the least squares method, network topics in the electrical, the design of building structures and the calculation of machine,measuring the earth and the economic operation of the input-output.Therefore, it is extremely significant to solve linear equations for practical problems. However, these equations are made of several hundred of unknown number, it will be viable and effective if solve linear equations using computer than Cramer's rule. This article main researches the two numerical solutions of linear equations, including direct methods and iterative methods, and uses Matlab to achieve the solution of these equations.Keyword:Linear Equations;Numerical Solution; direct method; iterative methods;Matlab目录摘要 .......................................................................................................................... .. (I)ABSTRACT ......................................................................................................... ................ II 绪论 (1)1．线性方程组数值解法的提出和定义 (2)1.1提出 (2)1.2定义 (2)2.线性方程组的直接解法及其计算机实现 (3)2.1 高斯消去法 (3)2.1.1 高斯消去法的定义及算法构造 (3)2.1.2用Matlab 作高斯消去法 (5)2.1.3 列主元消去法的定义与算法 (6)2.1.4用Matlab 作列主元消去法 (7)2.2矩阵三角分解法 (8)2.2.1直接三角分解法的定义及算法构造 (8) 2.2.2 直接三角分解法的适用条件 (10)2.2.3 用Matlab 作直接三角分解法 (10)2.3平方根法与改进的平方根法 (12)2.3.1平方根法的定义 (12)2.3.2改进的平方根法的定义 (13)2.3.3 用Matlab 作改进的平方根法 (14)2.4 解三对角线方程组的追赶法 (15)2.4.1追赶法的定义 (15)2.4.2 用Matlab 实现追赶法 (16)3. 线性方程组的迭代解法及其计算机实现 (18) 3.1 迭代法的定义 (18)3.2 雅克比迭代法 (18)3.2.1 雅克比迭代法定义 (18)3.2.2 用Matlab 实现雅克比迭代法 (19)3.3 高斯-赛德尔迭代法 (20)3.3.1高斯-赛德尔迭代法的定义 (20)3.3.2用Matlab 实现高斯-赛德尔迭代法 (21) 3.4 超松弛迭代法 (22)3.4.1超松弛迭代法的定义 (22)3.5迭代法的收敛性 (24)3.5.1向量范数和矩阵范数 (24)3.5.2迭代法的收敛性判断 (25)4.结论 (27)参考文献 (28)附录一 (29)附录二 (37)致谢 (42)大连大学学位论文版权使用授权书 (43)绪论对于线性方程组的求解，在中国古代的《九章算术》里面，解线性方程组的“方程术”方法是世界上最完备、最先的求解方法，而刘徽则提出了相对系统的方程理论。
课题线性方程组的直接解法
课题1. 线性方程组的直接解法问题提出：给定几个不同类型的线性方程组，请用适当的直接法求解。
一.C语言编程解各个方程组及其输出结果1.Gauss列主元消去法求解方程（1）C语言编程：#include<math.h>#include<stdio.h>#define NUM 20#define Esc 0x1b#define Enter 0x0dfloat A[NUM][NUM+1], ark;int flag;exchange(int r,int k);float max(int k);message();main(){float x[NUM];int r,k,i,j;char celect;clrscr();printf("use Gauss way to solve the equations?");printf("\nyes? then press Enter");printf("\nno? then press Esc");celect=getch();if(celect==Esc)exit(0);printf("\nenter n=");scanf("%d",&n);printf("\nenter A and b");for(i=1;i<=n;i++){printf ("enter a%d1--a%d%d and b%d ", i,i,n,i);for(j=1;j<=n+1;j++)scanf("%f",&A[i][j]);}for(k=1;k<=n-1;k++){ark=max(k);if(ark==0){printf("\n\n this is a wrong equation!");message(); }else if(flag!=k)exchange(flag,k) ;for(i=k+1;i<=n;i++)for(j=k+1;j<=n+1;j++)A[i][j]=A[i][j]-A[k][j]*A[i][k]/A[k][k];}for(i=1;i<=n;i++){printf("\n");for(j=1;j<=n+1;j++)printf("%f ",A[i][j]);}x[n]=A[n][n+1]/A[n][n];for(k=n-1;k>=1;k--){float u=0;for(j=k+1;j<=n;j++){u=u+A[k][j]*x[j];}x[k]=(A[k][n+1]-u)/A[k][k];}printf("\n");for(i=1;i<=n;i++)printf("x%d=%f" ,i,x[i]);message();}exchange(int r,int k){int i;for(i=1;i<=n+1;i++)A[0][i]=A[r][i];for(i=1;i<=n+1;i++)A[r][i]=A[k][i];for(i=1;i<=n+1;i++)A[k][i]=A[0][i];}float max(int k){int i;float temp=0;for(i=k;i<=n;i++)if(fabs(A[i][k])>temp){temp=fabs(A[i][k]);flag=i;}return temp;}message(){printf("\n\n continue press Enter ,exit press Esc!"); switch(getch()){case Enter: main();case Esc: exit(0);default:{printf("\nwrong!");message();}}}输出结果：2.gauss顺序消去法求解方程（1）C语言程序：#include<math.h>#include<stdio.h>#define NUM 20#define Esc 0x1b#define Enter 0x0dfloat A[NUM][NUM+1], ark;int flag;float max(int k);message();main(){float x[NUM];int r,k,i,j;char celect;clrscr();printf("use Gauss way to solve the equations?"); printf("\nyes? then press Enter");printf("\nno? then press Esc");celect=getch();if(celect==Esc)exit(0);printf("\nenter n=");scanf("%d",&n);printf("\nenter A and b");for(i=1;i<=n;i++){printf ("enter a%d1--a%d%d and b%d ", i,i,n,i);for(j=1;j<=n+1;j++)scanf("%f",&A[i][j]);}for(k=1;k<=n-1;k++){ark=max(k);if(ark==0){printf("\n\n this is a wrong equation!");message();}for(i=k+1;i<=n;i++)for(j=k+1;j<=n+1;j++)A[i][j]=A[i][j]-A[k][j]*A[i][k]/A[k][k];}for(i=1;i<=n;i++){printf("\n");for(j=1;j<=n+1;j++)printf("%f ",A[i][j]);}x[n]=A[n][n+1]/A[n][n];for(k=n-1;k>=1;k--){float u=0;for(j=k+1;j<=n;j++){u=u+A[k][j]*x[j];}x[k]=(A[k][n+1]-u)/A[k][k];}printf("\n");for(i=1;i<=n;i++)printf("x%d=%f" ,i,x[i]);message();}float max(int k){int i;float temp=0;for(i=k;i<=n;i++)if(fabs(A[i][k])>temp){temp=fabs(A[i][k]);flag=i;}return temp;}message(){printf("\n\n continue press Enter ,exit press Esc!"); switch(getch()){case Enter: main();case Esc: exit(0);default:{printf("\nwrong!");message();}}}输出结果：3.平方根法求解方程组（2）C语言编程：#include<math.h>#include<stdio.h>#define NUM 20#define Esc 0x1b#define Enter 0x0d#define NUM 20message();main(){float a[NUM][NUM], b[NUM],y[NUM],g[NUM][NUM],x[NUM],s,r; int m,k,i,j,n;char celect;clrscr();printf("use squart way to solve the equations?");printf("\nyes? then press Enter");printf("\nno? then press Esc");celect=getch();if(celect==Esc)exit(0);printf("\nenter n=");scanf("%d",&n);printf("\nenter a and b");for(i=1;i<=n;i++){printf ("enter a%d1--a%d%d ", i,i,n);for(j=1;j<=n;j++)scanf("%f",&a[i][j]);}printf("enter b") ;for(i=1;i<=n;i++)scanf("%f",&b[i]);g[1][1]=sqrt(a[1][1]);for(i=1;i<=n;i++)g[i][1]=a[i][1]/g[1][1];for(k=2;k<=n;k++){ s=0;for(m=1;m<=k-1;m++){ s=s+g[k][m]*g[k][m]; }g[k][k]=sqrt(a[k][k]-s);for(i=k+1;i<=n;i++){r=0;for(m=1;m<=k-1;m++){ r=r+g[i][m]*g[k][m]; }g[i][k]=(a[i][k]-r)/g[k][k];}}y[1]=b[1]/g[1][1];for(k=2;k<=n;k++){ r=0;for(m=1;m<=k-1;m++){ r+=g[k][m]*y[m];}y[k]=(b[k]-r)/g[k][k];}x[n]=y[n]/g[n][n];for(k=n-1;k>=1;k--){s=0;for(m=k+1;m<=n;m++)s+=g[m][k]*x[m];x[k]=(y[k]-s)/g[k][k];}for(i=1;i<=n;i++)printf("\nThe result are x[%d]=%f",i,x[i]); }message(){printf("\n\n continue press Enter ,exit press Esc!"); switch(getch()){case Enter: main();case Esc: exit(0);default:{printf("\nwrong!");message();}} }输出结果：4.追赶法解方程组（3）C语言编程：#include<stdio.h>#include<math.h>#define N 20main(){float a[N],c[N],d[N],b[N],x[N],y[N],A[N],B[N];int i,n;printf("\ninput n");scanf("%d",&n);printf("input a ");for(i=1;i<=n;i++)scanf("%f",&a[i]);printf("\ninput c ");for(i=1;i<=n-1;i++)scanf("%f",&c[i]);printf("input d ");for(i=2;i<=n;i++)scanf("%f",&d[i]);printf("input b ");for(i=1;i<=n;i++)scanf("%f",&b[i]);A[1]=a[1];for(i=1;i<=n-1;i++){B[i]=c[i]/A[i] ;A[i+1]=a[i+1]-d[i+1]*B[i];}y[1]=b[1]/A[1];for(i=2;i<=n;i++)y[i]=(b[i]-d[i]*y[i-1])/A[i];x[n]=y[n];for(i=n-1;i>=1;i--)x[i]=y[i]-B[i]*x[i+1];for(i=1;i<=n;i++)printf("x%d=%f ",i,x[i]);}输出结果：二．分析讨论1.对于不同类型的线性方程组应该采用与其相适合的方法对其进行求解，这样才能得到更为精确的解，如对于方程组（1）用Gauss列主元消去法更为合适；对于方程组（2）用平方根或改进平方根法均可；对方程组（3）适合采用追赶法求解。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数值计算小报告题目：线性方程组求解方法比较姓名和丽专业软件工程班级11级软件（2）班完成日期：2013 年5月18日摘要目前在许多实际应用领域,诸如航空、造船以及其它结构工程中,常遇到求解大型线性代数方程组的问题。
本文根据线性代数方程组的雅可比迭代法、LU分解法及高斯列主元消去法三种解法进行了比较，用以方便在实际生活应用中更好的作出选择。
在第二章中本文详细的介绍了线性代数方程组的三种解法的理论知识与证明过程。
为了更加清晰的展现三种方法的不同点以及其各自的优越性，本文在第三章中给出了实例，通过实例的计算与程序的实现，再结合三种方法的优缺点进行了比较。
关键字：线性代数方程组、迭代法、LU分解法、高斯列主元消去法、不同点、比较目录第一章绪论 (4)第二章求解线性方程组的基本理论2.1 迭代法 (5)2.2 直接三角分解法 (6)2.3 高斯消去法 (7)第三章三种算法求解方程组实例3.1 迭代法 (8)3.2 直接三角分解法 (10)3.3 高斯列主元消去法 (14)3.4 三种方法的优缺点比较 (16)参考文献 (17)第一章绪论计算数学是数学学科的一大分支，它研究如何借助于计算机求解各类数值问题。
应用计算机求解各类数值问题需要经历以下几个主要过程：1、实际问题2、数学模型3、计算方法4、算法设计5、计算求解目前已有的数学软件可以帮助我们实现上机计算，基本上已经将数值分析的主要内容设计成简单的函数，只要调用这些函数进行运算便可得到数值结果。
数值分析的内通包括线性代数方程组求解、非线性代数方程（组）求解、矩阵的特征值与特征值向量的计算、函数插值、函数逼近、数值积分与数值微分以及微分方程数值解法。
线性方程组的求解从理论上可分为两类：直接法和迭代法。
直接法是不考虑计算过程中的舍入误差，经过有限次的运算得到方程组精确解的方法，常见的方法是高斯顺序消去法、高斯列主元消去法和矩阵的LU分解法。
迭代法是采用某种极限过程，用线性代数方程组的近似解逐步逼近精确解的方法。
迭代法中常见的方法有简单迭代法、J-迭代法、GS-迭代法和SOR-迭代法。
本文主要是分析高斯列主元消去法、矩阵的LU分解法和简单迭代法理论上的异同，并用C语言程序通过具体实例进行了分析比较。
本文将线性方程组的求解过程用计算机实现，本文的编写由以下几个特点：1、对于难点问题从具体模型引入，淡化抽象的概念与定理，通俗易通；2、对于具体模型本文给出了多种解题的思想及方法；3、对问题进行简洁易懂的理论证明，突出了线性代数的理论和基本思想，使数学方法更加利于理解掌握。
4、简要分析了算法的计算效果、稳定性、收敛效果、计算精度以及优劣性。
第1章 求解线性方程组的基本理论1.1 迭代法迭代法的基本思想：是将线性方程组转化为便于迭代的等价方程组，对任选一组初始值错误!未找到引用源。
（i=1,2…n ），按某种计算规则，不断地对所得到的值进行修正，最终获得满足精度要求的方程组的近似解。
对于线性方程组Ax=b 其中，A 为非奇异矩阵。
将A 分裂为A=M-N ，其中，M 为非奇异矩阵，且要求线性代数方程组Mx=d 容易求解，一般选择为A 的某一部分元素构成的矩阵，称M 为A 的分裂矩阵。
于是，求解Ax=b 转化为求解Mx=Nx+b,由此可构造一个迭代法：x(0)(初始向量) ， x(k+1)=Bx(k)+f (k=0,1,2…)其中，f=b/M,B=I-A/M 为迭代法的迭代矩阵。
选取M 为A 的对角元素组成的矩阵，即选取M=D ，可得到解Ax=b 的迭代法：x(0)(初始向量),x(k+1)=Bx(k)+f (k=0,1,2…)B J 为求解Ax=b 的雅克比迭代法的迭代矩阵。
解迭代法的计算公式为：⎪⎩⎪⎨⎧--==∑∑+=-=+)(1),.......,,(1)(11)()1()0()0(2)0(1)0(n i j k j ij i j k j ij i ii k i T n x a x a b a x x x x X （k=0,1,2，……:i=1,2,3,……..n ） 迭代法方法是求对称矩阵的全部特征值以及相应的特征向量的一种方法，，它是基于以下两个结论：1)任何实对称矩阵A 可以通过正交相似变换成对角型，即存在正交矩阵Q ，使得 错误!未找到引用源。
AQ=diag(错误!未找到引用源。
) 其中错误!未找到引用源。
i （i=1,2,…,n ）是A 的特征值，Q 中各列为相应的特征向量。
2）在正交相似变换下，矩阵元素的平方和不变。
即设错误!未找到引用源。
，Q 为交矩阵，记B=错误!未找到引用源。
AQ=错误!未找到引用源。
,则错误!未找到引用源。
基本思想：是通过一次正交变换，将A 中的一对非0的非对角线化成0，并且使得非对角元素的平方和减小。
反复进行上述过程，使变换后的矩阵的非对角元素的平方和趋于0，从而使该矩阵近似为对角矩阵，得到全部特征值和特征向量。
1.2 直接三角分解法矩阵直接三角分解法：是高斯消去法的变形方法。
高斯消去法有多种变形，有的是高斯消去法的改进，有的是用于某种特殊系数矩阵的化简。
高斯消去法解线性方程组先消元，然后再回代。
当用矩阵描述时，是对系数矩阵分解为一个上三角阵和一个下三角阵的乘积，即LU 分解。
因此，高斯消去法与矩阵的LU分解是一致的。
将高斯消去法改写为紧凑形式，可以直接从矩阵A的元素得到计算L，U元素的递推公式，而不需要任何中间步骤，这就是所谓的直接三角分解法，一旦实现了矩阵A的LU分解，那么求解Ax=b的问题就等价于求解两个三角形方程组：错误!未找到引用源。
的问题，而这两个线性代数方程组只要回代，就可以求出其解。
设A为非奇异矩阵，且有分解式A=LU，其中L为单位下三角矩阵，U为单位上三角矩阵，A=错误!未找到引用源。
错误!未找到引用源。
第一步，用L的第一行分别乘以U的第j(j=1,2,…,n)列，比较两边可得错误!未找到引用源。
(j=1,2,…,n) 分别用L的第i(i=1,2,…,n)行乘U的第一列，比较可得错误!未找到引用源。
(i=1,2,…,n) 即得错误!未找到引用源。
(i=1,2,…,n) 这样就求出了L的第一列和U的第一行的所有元素。
依次进行下去，一直到第k-1步，即已求出L的前k-1列和U的前k-1行的所有元素。
第k步，用L的第k行分别乘U的第j(j=k,k+1,…,n)列，比较两边可得：错误!未找到引用源。
=错误!未找到引用源。
+…+错误!未找到引用源。
+错误!未找到引用源。
(j=k,k+1,…,n)分别用L的第i(i=k+1,…,n)行乘U的第k列，比较两边可得：错误!未找到引用源。
=错误!未找到引用源。
+…+错误!未找到引用源。
+错误!未找到引用源。
(i=k+1,…,n)总结上述讨论，得到用直接三角分解法求解Ax=b的计算公式：…,n), 错误!未找到引用源。
(i=2,3,…,n) 错误!未找到引用源。
(j=1,2,错误!未找到引用源。
(j=k,k+1,…,n)错误!未找到引用源。
(i=k+1,k+2,…,n)及求解Ly=b,Ux=y的计算公式：错误!未找到引用源。
(k=2,3,…,n)，错误!未找到引用源。
(k=n-1,n-2,…,2,1)1.3 高斯列主元消去法高斯顺序消去法的基本思想是：对线性代数方程组所对应的增广矩阵（A|b ）进行一系列“把某一行的非零常数倍加到另一行上”的初等变换，使得（A|b ）中A 的对角线一下的元素全变为0，从而使原方程组等价的转化为容易求解的上三角形线性代数方程组，再通过回代得到上三角形线性代数方程组的解，即可求得原方程组的解。
设线性方程组的增广矩阵为):():()1()1()1(b A b A A ===错误!未找到引用源。
首先，在第一列中选取绝对值最大的元素错误!未找到引用源。
作为第一列的主元，即 错误!未找到引用源。
然后交换第一行与第i 行，经一次消元计算得：错误!未找到引用源。
=(A 错误!未找到引用源。
B)错误!未找到引用源。
，此消去过程与高斯顺序消去法完全相同。
重复上述过程，设已完成第k-1步的选主元素，交换两行及消元过程后(A 错误!未找到引用源。
B)已约化为 错误!未找到引用源。
第k 步选主元素，在错误!未找到引用源。
右下角方阵的第一列内选取绝对值最大的元素错误!未找到引用源。
作为这一列的主元,即 错误!未找到引用源。
=错误!未找到引用源。
然后交换错误!未找到引用源。
的第i 行与第k 行，再进行消元计算。
如此重复，直到最后将原线性代数方程组化为 错误!未找到引用源。
错误!未找到引用源。
=错误!未找到引用源。
回代求解得到 错误!未找到引用源。
(k=n-1,…,2,1)列主元消去法除了每步需要按列选出主元，然后进行对换外，其消去过程与高斯顺序消去法是相同的。
第2章 三种方法求解方程组实例线性代数方程组的应用十分广泛，在实际生活中遇到的一些问题通常可以用求解方程组的方法来解决。
本章主要是通过实例介绍三种方法的应用以及其各种方法的优缺点比较。
例：用三种方法求解方程组 错误!未找到引用源。
的解。
2.1 迭代法解题步骤：将方程组记为Ax=b ，其中 A=错误!未找到引用源。
b=错误!未找到引用源。
将原方程组改写为错误!未找到引用源。
(1)也可写为 x=Bx+f 其中 B=错误!未找到引用源。
f=错误!未找到引用源。
任取初始值错误!未找到引用源。
=错误!未找到引用源。
,代入（1）式右边，得到新的值：错误!未找到引用源。
再将错误!未找到引用源。
代入（1）式右边得到错误!未找到引用源。
反复利用这个计算程序，得到一个向量序列和一般的计算公式：错误!未找到引用源。
=B错误!未找到引用源。
+f 其中k表示迭代次数（k=1,2,…）。
令错误!未找到引用源。
，由雅克比迭代公式错误!未找到引用源。
(k=0,1,2,…)有：D错误!未找到引用源。
于是，根据雅克比迭代法的计算公式可求出方程组的解。
迭代法代码：#include<math.h>#include<stdio.h>int gausdl(int n,double i[],double j[],double x[],double eps){ int u,v,w,r;double p,t,s,q;for(u=0;u<=n-1;u++){ w=u*n+u; p=0.0; x[u]=0.0;for (v=0; v<=n-1; v++)if(u!=v){ r=u*n+v; p=p+fabs(i[r]);}if(p>=fabs(i[w])){ printf("fail\n"); return(-1);}}p=eps+1.0;while (p>=eps){ p=0.0;for (u=0; u<=n-1; u++){ t=x[u]; s=0.0;for (v=0;v<=n-1;v++)if (v!=u) s=s+i[u*n+v]*x[v];x[u]=(j[u]-s)/i[u*n+u];q=fabs(x[u]-t)/(1.0+fabs(x[u]));if (q>p) p=q;}}return(1);}void main(){ int u;double eps;static double i[16]={2.0,0.0,0.0,1.0,2.0,3.0,2.0,4.0,-3.0,0.0,1.0,6.0,1.0,-6.0,-5.0};static double x[5],j[4]={0.0,-2.0,-7.0,6.0};eps=0.000001;if (gausdl(4,i,j,x,eps)>0)for (u=0;u<=3;u++)printf("x(%d)=%13.7e\n",u,x[u]);｝}运行结果：x1=-3.500000e+000x2=0.000000e+000x3=-3.000000e+000x4=7.000000e+0002.2 直接三角分解法解题步骤：将方程组改写为错误!未找到引用源。