精华内容
下载资源
问答
  • 列主元消元法解方程组

    千次阅读 2015-01-17 14:05:03
    列主元消元法的算法步骤: # include # include # define N 3 main(){ int i,j,k,h,s,m,n,z; float max(float *y); float A[N][N+1],B[N],ma,t,M[N]={0},X; float x[N]; /*输入系数矩阵 */ ...

    列主元消元法的算法步骤:

    # include<stdio.h>
    # include<math.h>
    # define N 3
    main(){
    	int i,j,k,h,s,m,n,z;
        float max(float *y);
        float A[N][N+1],B[N],ma,t,M[N]={0},X;
    	float x[N];
    
    /*输入系数矩阵 */
    
    for(i=0;i<N;i++)
       for(j=0;j<N+1;j++)
    	   scanf("%f",&A[i][j]);
    
     printf("向命令窗口输入的曾广矩阵是:\n"); 
     
       for(i=0;i<N;i++)
     {
       for(j=0;j<N+1;j++)
    	   printf("%2.1f  ",A[i][j]);
       printf("\n");
     }
    	
    
    /*正消过程*/
    	for (i=0;i<N-1;i++)
    	{
    
    		 /*找出每行最大的值 */
    		for (j=i;j<N;j++)
    			B[j-i]=A[j][i];
    		ma=max(B);
    		for (s=0;s<N;s++)
    			B[s]=0;
    
    		/* 交换最大值行和当前行 */
    		if(ma!=0){
    		for (k=i;k<N;k++)
    			if (A[i][i]!=ma && A[k][i]==ma && ma!=0)
    			{
    				for (h=0;h<N+1;h++)
    				{
    					t=A[i][h];
    					A[i][h]=A[k][h];
    					A[k][h]=t;
    				}
    			}
    		      }
    		      else
    		      { printf("A是非奇异矩阵!\n");
    		      break;
    		      } 
    
    		/*	消去过程   */
    			for (m=i+1;m<N;m++)
    				M[m]=A[m][i]/A[i][i];
    			for (n=i+1;n<N;n++)
    			{
    				for (z=0;z<N+1;z++)
    					A[n][z]=A[n][z]-M[n]*A[i][z];
    			}
    			for (m=0;m<N;m++)
    				M[m]=0;
    	}
    	/*输出三角矩阵  */
    
    printf("通过高斯列主元消去法化成的上三角曾广矩阵是:\n");      
     for(i=0;i<N;i++)
     {
       for(j=0;j<N+1;j++)
    	   printf("%2.1f  ",A[i][j]);
       printf("\n");
     }
     /*
     回带过程
     */
     x[N-1]=A[N-1][N]/A[N-1][N-1];
     for(i=N-2;i>0 || i==0;i--)
     {   
    	 for(j=N-1;j>i;j--)
    		 X=X+A[i][j]*x[j];
    	 x[i]=(A[i][N]-X)/A[i][i];
    	 X=0; 
     }
    	  /*
    将方程的解输出
      */
    printf("该方程组的解依次为:\n");
     for(i=0;i<N;i++){
     	printf("x[%d]=%2.1f   ",i+1,x[i]);
     } 
    }
    
    
    /*
    计算最大值函数
      */
    float max(float *y){
    	int w;
    	float max=y[0];
    	for (w=0;w<N;w++)
    
    		if (fabs(y[w])>fabs(max))
    			max=y[w];
    			return max;
    }


    运行结果;

    展开全文
  • 利用高斯列主元消元法求解方程组的C++代码,用VC++6.0实现,通过更改输入参数可求一般线性方程组
  • Gauss列主元消元法解线性方程组(通用)
  • 高斯列主消元法解线性方程输入有方程组可得到阶梯矩阵与相应的无穷多时只得到阶梯矩阵
  • 列主元消元法求线性方程组方程组在程序中输入指定,C语言
  • 懒得介绍了,方法思路看书 CPP代码 在这里插入代码片

    题
    高斯消元的优化,为了避免分母过小造成的误差,在每次选取基准数的时候在每列中选择最大的那个并于该行做初等行变换,该代码的时间复杂度为 O ( N 4 ) O(N^4) O(N4)

    CPP代码

    /*
    WANG_zibi 列消元 
     
    */
    #include <bits/stdc++.h>
    #define int long long
    using namespace std;
    typedef pair<int, int> PII;
    const int N = 1e4 + 10;
    double a[N][N];
    int n, m;
    const double INF = 0x3f3f3f3f;
    void test()
    {
        printf("经过变换的矩阵为:\n");
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
                cout << a[i][j] << " ";
            puts("");
        }
    }
    void deal(int x)
    {
        pair<double, int> flag;
        flag.first = flag.second = -INF;
        for (int i = x + 1; i < n; i++)
        {
            if (a[i][x] > flag.first)
            {
                flag.first = a[i][x];
                flag.second = i;
            }
        }
        if(flag.second!=-INF)
        for (int i = 0; i < m; i++)
                swap(a[flag.second][i], a[x][i]);
    }
    void gauss()
    {
        for (int k = 0; k < n; k++)
        {
            deal(k);
            for (int i = k + 1; i < n; i++)
            {
            	
                double t = a[i][k] / a[k][k];
                for (int j = k; j < m; j++)
                {
                    a[i][j] -= a[k][j] * t;
                }
            }
        }
        
        for (int j = 2; j >= 0; j--)
        {
            for (int k = j + 1; k < 3; k++)
            {
                a[j][3] = a[j][3] - a[j][k] * a[k][k];
            }
            a[j][j] = a[j][3] / a[j][j];
        }
    }
    
    void solve()
    {
        printf("最终得到的x1,x2,x3分别为:\n");
        for (int i = 0; i < 3; i++)
            cout << a[i][i] << " ";
    }
    signed main()
    {
        cin >> n >> m;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                cin >> a[i][j];
        test(); 
        gauss();
        solve();
        return 0;
    }
    
    

    PYTHON代码

    class gauss:
        def __init__(self, M, nn, mm):
            self.Matrix = M
            self.n = nn
            self.m = mm
        def __deal(self, t):
            x = -9999999.0
            y = None
            for i in range(t+1,self.n):
                if(self.Matrix[i][t] > x):
                    x = self.Matrix[i][t]
                    y=i
                for i in range(0,self.m):
                    temp = self.Matrix[t][i]
                    self.Matrix[t][i] = self.Matrix[y][i]
                    self.Matrix[y][i]=temp
    
        def solve(self):
            for k in range(0, self.n):
                self.__deal(k)
                for i in range(k + 1, self.n):
                    t = self.Matrix[i][k] / self.Matrix[k][k]
                    for j in range(0, self.m):
                        self.Matrix[i][j] -= self.Matrix[k][j] * t
            for j in range(self.n - 1, -1, -1):
                for k in range(j + 1, self.n):
                    self.Matrix[j][self.n] = self.Matrix[j][self.n] - self.Matrix[j][k] * self.Matrix[k][k]
                self.Matrix[j][j] = self.Matrix[j][self.n] / self.Matrix[j][j]
    
            for i in range(0, self.m - 1):
                print(self.Matrix[i][i], end=' ')
    
    def main():
        n,m=map(int, input().split())
        line = [[0] * m] * n
        for i in range(n):
            line[i] = input().split(" ")
            line[i] = list(map(int,line[i]))
        G = gauss(line,n,m)
        G.solve()
    main()
    
    
    展开全文
  • 高斯消元法都知道,列主元消元法也就是改进了一下可以使某一列主元很小的时候实现精确化。 在消元过程中,无法使主元素a(ii)≠0,但是很小时,用其做除数,会导致其他元素数量级的严重增长,舍入误差的扩展,最后...

    方程已给定:
    在这里插入图片描述
    高斯消元法都知道,列主元消元法也就是改进了一下可以使某一列主元很小的时候实现精确化。
    在消元过程中,无法使主元素a(ii)≠0,但是很小时,用其做除数,会导致其他元素数量级的严重增长,舍入误差的扩展,最后导致计算结果不可靠。所以这次采用列主元素消去法来进行,思想就是将有小数的那行与该列中数最大的那行进行交换。

    #include<iostream>
    #include<math.h>
    using namespace std;
    
    struct  Gauss {
    	double A[4][5];
    	double B[2][5];
    	double x1, x2, x3;
    	 Gauss() {
    		A[1][1] = 0.9428;
    		A[1][2] = 0.3475;
    		A[1][3] = -0.8468;
    		A[1][4] = 0.4127;
    		A[2][1] = 0.3475;
    		A[2][2] = 1.8423;
    		A[2][3] = 0.4759;
    		A[2][4] = 1.7321;
    		A[3][1] = -0.8468;
    		A[3][2] = 0.4759;
    		A[3][3] = 1.2147;
    		A[3][4] = -0.8621;
    	}
    public:
    
    	void find(int a, int b) {
    		double max = A[a][b];
    		int a1=a, b1=b;
    		for (int i = a; i <= 3; i++) {
    			for (int j = b; j <= 3; j++) {
    				if (abs(max) < abs(A[i][j]))
    				{
    					max = A[i][j];
    					a1 = i;
    					b1 = j;
    				}
    			}
    		}
    		for (int i = 1; i < 5; i++) {
    			swap(A[a][i], A[a1][i]);
    		}
    		for (int i = 1; i < 4; i++) {
    			swap(A[i][b], A[i][b1]);
    		}
    		cout << "列主元消元法变换结果如下:" << endl;
    		for (int i = 1; i < 4; i++) {
    			for (int j = 1; j < 5; j++)
    				cout << A[i][j] << "  ";
    			cout << endl;
    		}
    		cout << endl;
    	}
    
    	void resultGauss1() {
    		for (int i = 1; i < 3; i++) {
    			for (int d = 1; d < 4 - i; d++) {
    				double k = 0;
    				k = A[i + d][i] / A[i][i];
    				for (int j = 1; j < 5; j++) {
    					A[i + d][j] = A[i + d][j] - A[i][j] * k;
    				}
    			}
    		}
    		cout << "牛顿消元法结果如下:" << endl;
    		x3 = A[3][4] / A[3][3];
    		x2 = (A[2][4] - A[2][3] * x3) / A[2][2];
    		x1 = (A[1][4] - A[1][3] * x3 - A[1][2] * x2) / A[1][1];
    		for (int i = 1; i < 4; i++) {
    			for (int j = 1; j < 5; j++)
    				cout<<A[i][j] <<"  ";
    			cout << endl;
    		}
    		cout << "x1:" << x1 << "  x2: " << x2 << "  x3: " << x3 << endl;
    	}
    	void resultGauss2() {
    		for (int i = 1; i < 3; i++) {
    			find(i, i);
    			for (int d = 1; d < 4 - i; d++) {
    				double k = 0;
    				k = A[i + d][i] / A[i][i];
    				for (int j = 1; j < 5; j++) {
    					A[i + d][j] = A[i + d][j] - A[i][j] * k;
    				}
    			}
    		}
    		x3 = A[3][4] / A[3][3];
    		x2 = (A[2][4] - A[2][3] * x3) / A[2][2];
    		x1 = (A[1][4] - A[1][3] * x3 - A[1][2] * x2) / A[1][1];
    		for (int i = 1; i < 4; i++) {
    			for (int j = 1; j < 5; j++)
    				cout << A[i][j] << "  ";
    			cout << endl;
    		}
    		cout << "x1:" << x3 << "  x2: " << x1 << "  x3: " << x2 << endl;
    	}
    };
    
    int main() {
    	Gauss gauss;
    	gauss.resultGauss1();
    	cout << endl;
    	gauss.resultGauss2();
    	system("pause");
    	return 0;
    }
    
    
    
    展开全文
  • 列主元Gauss消去是指在解方程组时,未知数顺序消去,在要消去的那个未知数的系数中找按模最大者作为主元.完成消元后,系数矩阵化为上三角形,然后在逐步回代求解未知数.列主元Gauss消去是在综合考虑运算量与舍人误差...
  • 这些天有点闲,就花了一点时间把这个问题写出来了。其实知道这个在MATLAB上,一句话就可以解决了。我也是太久的时间写算法... //高斯列主元消元法 private void gauss(double[,] aa) { int h = aa.GetLength(0);//行数

        这些天有点闲,就花了一点时间把这个问题写出来了。其实知道这个在MATLAB上,一句话就可以解决了。我也是太久的时间写算法啊这些东西了。权当练练手。

    展开全文
  • 利用高斯先列主元消元的思想,采用VC编程实现求解线性方程组
  • 高斯列主元消去法解线性方程组
  • 用高斯用列主元消元法求解下面的方程组.doc
  • 列主元消元法比起高斯消元增加了每次化简时取第一列最大元素作为主元 即: 题目: 代码: #include <iostream> #include <cstdio> #include <queue> #include <cstring> #include <...
  • 高斯列主元消元法求解线性方程组

    万次阅读 2014-01-05 23:35:26
    一、高斯消去的基本思想 ... 解方程组:   方程组矩阵形式为:AX=b,其中:    第一步,消元过程:对增广矩阵进行消元   即得方程组   第二步, 回代过程:   此方法就是高斯消去。 二、改进版
  • 算法步骤 例题 程序代码 function x=liezhuyuan(A,b) k=1; n=length(b); m=zeros(n,n); X=A Y=b for k=1:n-1 [ark,rk]=max(abs(A(k:n,k))); rk=k-1+rk; if rk>k link=A(k,:);... ..
  • 高斯列主元消去法解方程组,用C语言描述了高斯列主元消去法解方程组的过程
  • 列主元Gauss消去求解方程组,代码分为两部分:通用列主元高斯消去和线性方程组求解
  • (16)Gauss列主元消去法解方程组 补发笔记
  • 数值分析里面经常会涉及到用MATLAB程序实现用列主元消去分别解方程组Ax=b 具体的方法和代码以如下方程(3x3矩阵)为例进行说明: 用列主元消去分别解方程组Ax=b,用MATLAB程序实现: (1) 1、 实现...
  • 列主元高斯消去法解线性方程组的MATLAB程序,参考教材《数值分析》李乃成
  • 数值分析—列主元消去法解线性方程组—FORTRAN程序 program main implicit none integer::i,n !用矩阵(实型动态数组)将线性方程组表示出来 real8,dimension(:
  • 高斯列主元法解方程组 vc环境下运行即可 可以连续多个方程 输入的参数是方程系数增广矩阵
  • 列主元高斯消去法解线性方程组的程序,参考教材《数值分析》
  • MATLAB 列主元消去 解方程组

    千次阅读 2019-09-04 15:13:23
    %把方程组系数矩阵A化为同的上三角矩阵 b=B(1:n,n+1); A=B(1:n,1:n); X(n)=b(n)/A(n,n); for q=n-1:-1:1 X(q)=(b(q)-sum(A(q,q+1:n)*X(q+1:n)))/A(q,q); end %从xn至x1逐个求解上三角方程组 else ...
  • 列主元消去法解线性方程组(C++实现) #include<cstdio> #include<iostream> using namespace std; int quen(double a[],int n){ double x; int k; for(int i=0;i<n;i++){ if(a[i]>=0){ a...
  • 用c++程序实现高斯列主元消去法解方程组 简单易懂
  • 主要包含列主元Gauss消元法的算法流程和python实现,并且以教科书上的一个例题加以验证

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 420
精华内容 168
关键字:

列主元消元法解方程组