精华内容
下载资源
问答
  • 利用高斯约旦法求高阶逆矩阵,最大的优势便是节省内存空间。
  • Java求逆矩阵高斯约旦法),很经典哦!!!Java求逆矩阵高斯约旦法),很经典哦!!!Java求逆矩阵高斯约旦法),很经典哦!!!
  • 这是一个JAVA类,,实现用高斯约旦法求矩阵,这个类判断了矩阵是否能求逆,代码清晰,易于读懂。
  • 全选主元高斯约旦矩阵求逆算法,matlab语言编写,程序中对比了算法与matlab函数求结果,结果一致。
  • 高斯-约旦法矩阵求逆算法,比较适合编程
  • 此应用程序通过消除Gauß-Jordan来求逆矩阵。 它支持最大10x10的矩阵。 它显示了计算以及解决方案。 对分数的支持即将推出
  • // 计算逆矩阵 // 第二步 m(k, k) = 1.0f / m(k, k); // 第三步 for (DWORD j = 0; j ; j ++) { if (j != k) m(k, j) *= m(k, k); } // 第四步 for (DWORD i = 0; i ; i ++) { if (i != k) { for (j = 0; j ; j ++...

    float Inverse(CLAYMATRIX& mOut, const CLAYMATRIX& rhs)

    {

    CLAYMATRIX m(rhs);

    DWORD is[4];

    DWORD js[4];

    float fDet = 1.0f;

    int f = 1;

    for (int k = 0; k < 4; k ++)

    {

    // 第一步,全选主元

    float fMax = 0.0f;

    for (DWORD i = k; i < 4; i ++)

    {

    for (DWORD j = k; j < 4; j ++)

    {

    const float f = Abs(m(i, j));

    if (f > fMax)

    {

    fMax        = f;

    is[k]        = i;

    js[k]        = j;

    }

    }

    }

    if (Abs(fMax) < 0.0001f)

    return 0;

    if (is[k] != k)

    {

    f = -f;

    swap(m(k, 0), m(is[k], 0));

    swap(m(k, 1), m(is[k], 1));

    swap(m(k, 2), m(is[k], 2));

    swap(m(k, 3), m(is[k], 3));

    }

    if (js[k] != k)

    {

    f = -f;

    swap(m(0, k), m(0, js[k]));

    swap(m(1, k), m(1, js[k]));

    swap(m(2, k), m(2, js[k]));

    swap(m(3, k), m(3, js[k]));

    }

    // 计算行列值

    fDet *= m(k, k);

    // 计算逆矩阵

    // 第二步

    m(k, k) = 1.0f / m(k, k);

    // 第三步

    for (DWORD j = 0; j < 4; j ++)

    {

    if (j != k)

    m(k, j) *= m(k, k);

    }

    // 第四步

    for (DWORD i = 0; i < 4; i ++)

    {

    if (i != k)

    {

    for        (j = 0; j < 4; j ++)

    {

    if (j != k)

    m(i, j) = m(i, j) - m(i, k) * m(k, j);

    }

    }

    }

    // 第五步

    for (i = 0; i < 4; i ++)

    {

    if (i != k)

    m(i, k) *= -m(k, k);

    }

    }

    for        (k = 3; k >= 0; k --)

    {

    if (js[k] != k)

    {

    swap(m(k, 0), m(js[k], 0));

    swap(m(k, 1), m(js[k], 1));

    swap(m(k, 2), m(js[k], 2));

    swap(m(k, 3), m(js[k], 3));

    }

    if (is[k] != k)

    {

    swap(m(0, k), m(0, is[k]));

    swap(m(1, k), m(1, is[k]));

    swap(m(2, k), m(2, is[k]));

    swap(m(3, k), m(3, is[k]));

    }

    }

    mOut = m;

    return fDet * f;

    }

    展开全文
  • #include"iostream.h" ...cout该矩阵逆矩阵为:\n\n"; for(i=1;i;i++) { cout|"; for(j=1;j;j++) { cout; } cout|"; cout; } //------------------------------------------------------------------ }
    #include"iostream.h"
    #include"math.h"
    void main()
    {
    float a[10][10],A[10][10],b[10],c[10][10],d=0,f=0;
    int i=0,j=0,k=1,l=0,m=0,n=0;
    //------------------------------------------------------------------
    cout<<"请输入你所求矩阵的阶数:\n";
    cin>>n;
    cout<<"请输入原矩阵:\n";
    for(int r=1;r<=n;r++)
    {
    cout<<"|";
    for(int s=1;s<=n;s++){cin>>c;}
    }
    //------------------------------------------------------------------
    for(m=1;m<=n;m++)
    {
    for(int i=1;i<=n;i++)
    {
    for(int j=1;j<=n;j++)
    {
    a=c;
    }
    }
    for(i=1;i<=n;i++)
    {
    b=0;
    }
    b=1;
    //*******************************************************************************
    //************************列选主元************************
    for(k=1;k<=n;k++)
    {
    d=a;
    l=k;
    for(i=k+1;i<=n;i++)
    {
    if(fabs(a)>fabs(d))
    {
    d=a;
    l=i;
    }
    }
    if(l!=k)
    {
    for(j=k;j<=n;j++)
    {
    f=a;
    a=a;
    a=f;	
    }
    f=b;
    b=b;
    b=f;
    }
    //************************消元************************
    
    for(j=k+1;j<=n;j++)
    {
    a=a/a;//第k行除以主元
    }
    b=b/a;//第k行除以主元
    for(i=1;i<=n;i++)
    {
    if(i!=k)
    {
    for(j=k+1;j<=n;j++)
    {
    a=a-a*a;
    
    }
    b=b-a*b;
    }
    }
    }
    //*******************************************************************************
    for(i=1;i<=n;i++)
    {
    A=b;
    }	
    }
    cout<<"该矩阵的逆矩阵为:\n\n";
    for(i=1;i<=n;i++)
    {
    cout<<"|";
    for(j=1;j<=n;j++)
    {
    cout<<' '<<A<<' ';
    }
    cout<<"|";
    cout<<endl<<endl;
    }
    //------------------------------------------------------------------
    }

    展开全文
  • 我们用高斯-约旦消元把分块矩阵: A|E 中的A初等变化为E , 整体矩阵变为: 输入右块矩阵即可。 #include <bits/stdc++.h> using namespace std; typedef long long ll; const int M = 400+7; const int mod...

    以上是我们算法的依据

    下面的是例题。

    我们用高斯-约旦消元把分块矩阵: A|E  中的A初等变化为E ,  整体矩阵变为: E|A^ {-1}

    输入右块矩阵即可。

    #include <bits/stdc++.h>
    using namespace std;
    typedef long long ll;
    const int M = 400+7;
    const int mod =1e9+7;
    int a[M][M<<1];
    ll qpow(ll a,ll b)
    {
    	ll ans=1;
    	while(b)
    	{
    		if(b&1)ans=ans*a%mod;
    		a=a*a%mod;
    		b>>=1;
    	}
    	return ans;
    }
    //返回自由元个数,及无穷解个数 
    bool Gauss(int n,int m)//对矩阵a高斯消元得到(E|C) C为等式右边的列矩阵 
    {
    	int row;//当前处理的行
    	int col;//当前处理的列 
      	for(row=1,col=1;row<=n&&col<=n;row++,col++)
      	{
      		int mx=row;
      		for(int i=row+1;i<=n;i++)if(abs(a[i][col])>abs(a[mx][col]))mx=i;
      		if(mx!=row)swap(a[row],a[mx]);
      		if(a[row][col]==0)//第i行一下的i列都是0 ,处理下一列 ,这种情况下会出现 无穷解或无解 
      			return -1;
      		ll inv=qpow(a[row][col],mod-2);
      		for(int i=1;i<=n;i++)
      		{
      			 if(row==i)continue;
      			 ll tmp=a[i][col]*inv%mod;//第i行减去第row行 * tmp,消去第i行的第col列 
      			 for(int j=col;j<=m;j++)
      			 	a[i][j]=(a[i][j]-tmp*a[row][j]%mod+mod)%mod;//cout<<"----    "<<i<<" "<<j<<" "<<a[i][j]<<endl;;
    		}
    		for(int j=col;j<=m;j++)a[row][j]=inv*a[row][j]%mod;
    	}
    	return 0;
    }
    int main()
    {
      	int n;
      	scanf("%d",&n);
      	for(int i=1;i<=n;i++)
      		for(int j=1;j<=n;j++)scanf("%d",&a[i][j]);
    	for(int i=1;i<=n;i++)a[i][i+n]=1;
      	int f=Gauss(n,2*n);
      	if(f!=0)
      	{
      		puts("No Solution");
      		return 0;
    	}
      	for(int i=1;i<=n;i++)
      	for(int j=1;j<=n;j++)
      	{
      		
      		if(j==n)printf("%lld\n",a[i][j+n]);
      		else printf("%lld ",a[i][j+n]); 
    	}
    	return 0;
    }

     

    展开全文
  • 高斯约旦消元法求n阶矩阵 本代码以四阶矩阵为例,需要求更高次的,只需要将代码中的4修改下即可 // gaussJordan.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include <iostream> #...

    高斯约旦消元法求n阶矩阵的逆

    本代码以四阶矩阵为例,需要求更高次的,只需要将代码中的4修改下即可
    // gaussJordan.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    //
    
    #include <iostream>
    #include <opencv2/opencv.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    #include <opencv2/highgui/highgui.hpp>
    
    using namespace std;
    using namespace cv;
    
    
    void step0(double m, double newMat[4][4]);
    void step1(double m, double swap[4], double l[4][4], double mat11[4][4]);
    void step2(double m, double mat11[4][4], double l1[4][4]);
    void step3(double m, double mat11[4][4], double l2[4]);
    void gaussJordan(int m, double mat11[4][4]);
    
    void step0(double m, double newMat[4][4]) {
    	for (int i = 0; i < 4; i++) {
    		for (int j = 0; j < 4; j++) {
    			if (i == j) {
    				newMat[i][j] = 1;
    			}
    			else {
    				newMat[i][j] = 0;
    			}
    		}
    	}
    }
    
    void step1(double m, double swap[4], double l[4][4], double mat11[4][4]) {
    	for (int i = 0; i < 4; i++) {
    		swap[i] = i;
    		for (int j = 0; j < 4; j++) {
    			l[i][j] = 0;
    		}
    	}
    	for (int i = 0; i < 4; i++) {
    		double max_row = mat11[i][i];
    		int row = i;
    		for (int j = i; j < 4; j++) {
    			if (mat11[j][i] >= max_row) {
    				max_row = mat11[j][i];
    				row = j;
    			}
    		}
    		swap[i] = row;
    		if (row != i) {
    			for (int j = 0; j < 4; j++) {
    				double swapk = mat11[i][j];
    				mat11[i][j] = mat11[row][j];
    				mat11[row][j] = swapk;
    			}
    		}
    		for (int j = i+1; j < 4; j++) {
    			if (mat11[j][i] != 0) {
    				l[j][i] = mat11[j][i] / mat11[i][i];
    				for (int k = 0; k < 4; k++) {
    					mat11[j][k] = mat11[j][k] - (l[j][i] * mat11[i][k]);
    				}
    			}
    		}
    	}
    }
    
    void step2(double m, double mat11[4][4], double l1[4][4]) {
    	int longM = m - 1;
    	for (int i = 0; i < 4; i++) {
    		for (int j = 0; j < 4; j++) {
    			l1[i][j] = 0;
    		}
    	}
    	for (int i = 0; i < 4 - 1; i++) {
    		for (int j = 0; j < longM - i; j++) {
    			if ((mat11[longM - i - j - 1][longM - i] != 0) && (mat11[longM - i][longM - i] != 0)) {
    				l1[longM - i - j - 1][longM - i] = mat11[longM - i - j - 1][longM - i] / mat11[longM - i][longM - i];
    				for (int k = 0; k < 4; k++) {
    					mat11[longM - i - j - 1][k] = mat11[longM - i - j - 1][k] - l1[longM - i - j - 1][longM - i] * mat11[longM - i][k];
    				}
    			}
    		}
    	}
    }
    
    void step3(double m, double mat11[4][4], double l2[4]) {
    	for (int i = 0; i < 4; i++) {
    		l2[i] = mat11[i][i];
    	}
    }
    
    void gaussJordan(int m, double mat11[4][4]) {
    	double newMat[4][4], swap[4], l[4][4], l1[4][4], l2[4];
    	step0(4, newMat);
    	step1(4, swap, l, mat11);
    	step2(4, mat11, l1);
    	step3(4, mat11, l2);
    
    	for (int i = 0; i < 4; i++) {
    		if (swap[i] != i) {
    			for (int j = 0; j < 4; j++) {
    				double swapk1 = newMat[i][j];
    				int k1 = swap[i];
    				newMat[i][j] = newMat[k1][j];
    				newMat[k1][j] = swapk1;
    			}
    		}
    		for (int j = i + 1; j < 4; j++) {
    			for (int k = 0; k < 4; k++) {
    				if (l[j][i] != 0) {
    					newMat[j][k] = newMat[j][k] - l[j][i] * newMat[i][k];
    				}
    			}
    		}
    	}
    	for (int i = 0; i < 4 - 1; i++) {
    		for (int j = 0; j < 4 - i - 1; j++) {
    			if (l1[4 - 1 - i - j - 1][4 - 1 - i] != 0) {
    				for (int k = 0; k < 4; k++) {
    					newMat[4 - 1 - i - j - 1][k] = newMat[4 - 1 - i - j - 1][k] - l1[4 - 1 - i - j - 1][4 - i - 1] * newMat[4 - i - 1][k];
    				}
    			}
    		}
    	}
    	for (int i = 0; i < 4; i++) {
    		for (int j = 0; j < 4; j++) {
    			newMat[i][j] = newMat[i][j] / l2[i];
    		}
    	}
    	for (int i = 0; i < 4; i++) {
    		for (int j = 0; j < 4; j++) {
    			cout << newMat[i][j] << endl;
    		}
    	}
    }
    
    int main()
    {
    	double mat11[4][4] = { {3.54677704e+02, 1.03740405e+03, 3.67944094e+05, 1.00000000e+00},
    	{1.45565262e+02, 6.24826965e+02, 9.09531016e+04, 1.00000000e+00},
    	{7.50557922e+02, 7.80734863e+02, 5.85986750e+05, 1.00000000e+00},
    	{4.80305298e+02, 4.25448975e+02, 2.04345391e+05, 1.00000000e+00} };
    	gaussJordan(4, mat11);
    }
    

    有问题可以加入我的群,QQ群号109530447

    展开全文
  • 矩阵求逆算法-全选主元高斯-约旦法 Tags: 矩阵 全选主元高斯-约旦法的步骤如下: 1. 对于 k 从 0 到 n - 1 作如下几步: 从第 k 行、第 k 列开始的右下角子阵中选取绝对值最大的元素,并记住次元素所在的...
  • 高斯消元法矩阵求逆

    2018-08-21 16:50:30
    利用高斯消元法求矩阵逆矩阵,C++代码,效率极高,windows平台下测试通过,可以移植到嵌入式平台下
  • 高斯约旦求矩阵

    2010-12-08 15:51:56
    #include<iostream> usingnamespacestd; #definen3 intmain() { inti,j,k; doublem; doublea[n][n],E[n][n]; //单位矩阵E[n][n] for(i=0;i<n;i++) ...
  • 矩阵求逆高斯-约旦法

    千次阅读 2011-03-31 11:13:30
    算法介绍 ...这里要介绍的矩阵求逆算法称为全选主元高斯-约旦法高斯-约旦法(全选主元)求的步骤如下: 首先,对于 k 从 0 到 n - 1 作如下几步: 从第 k 行、第 k 列开始的右下角子阵中...
  • 高斯约旦法

    千次阅读 2017-04-29 11:25:50
    高斯约旦法的想法就是高斯消去的进一步扩展,理解起来不算特别困难,但是就是在构造的过程中有些困难。 代码#include<stdio.h> //高斯约旦法 #include #define max 10 void gaosiyuedan(int n,double a[max][max]...
  • P4783 【模板】矩阵求逆 题目描述 求一个N×NN×NN×N的矩阵的矩阵。答案对109+710^9+7109+7取模。 1.矩阵的定义 假设 AAA 是一个方阵,如果存在一个矩阵 A−1A^{-1}A−1,使得 A−1A=IA^{-1}A=IA−1A=I 并且 AA...
  • 高斯消元法求N阶矩阵逆矩阵 用c语言编写 很经典 很实用
  • 选主元的高斯-约当(Gauss-Jordan)消元在很多地方都会用到,例如一个矩阵逆矩阵、解线性方程组(插一句:LM算法求解的一个步骤),等等。它的速度不是最快的,但是它非常稳定(来自网上的定义:一个计算方法...
  • 高斯约旦消去求解线性方程组的完整C++代码,能够运行。
  • 通过搜索网络资源找到了使用部分主元的高斯消去求解逆矩阵的算法分享给大家。 2、算法实现 //******************************** //*** 任何一个矩阵*** //******************************** #i
  • Gauss-Jordan法求逆矩阵

    千次阅读 2017-08-10 14:06:17
    转载来源于: http://student.zjzk.cn/course_ware/web-gcsx/gcsx/chapter3/chapter3.2.htm ... 先回顾一下高斯消元: §1.2 消元矩阵的初等
  • 高斯消元高斯约旦消元

    千次阅读 2016-11-04 15:57:20
    1、高斯消元的算法 (设akk(k)不等于0) ...将非零阵A=(aij)m×n,经过行初等变化,变为上三角矩阵。...此方法常用于解线性方程组和矩阵的秩的计算。如例1中矩阵A的秩r(A)=3。...2、高斯约旦消元的算法
  • //高斯消去不能将原始矩阵化为三角形的格式,  //那就代表原始矩阵是一个不可逆的矩阵,  return 0;  }  }  //将原始矩阵转化成单位矩阵  for(i=n-1;i>=0;i--)  {  HH(i);  }  ...
  • /*算法没有做过什么改动,加上了内存释放的部分。...这里要介绍的矩阵求逆算法称为全选主元高斯-约旦法高斯-约旦法(全选主元)求的步骤如下:首先,对于 k 从 0 到 n - 1 作如下几步:从第 k 行、第 k 列...
  • 高斯-约旦消元使得GGG变成EEE.那么原单位矩阵EEE即变为G−1G^{-1}G−1 在过程中若出现自由元,则它不存在. #include<bits/stdc++.h> using namespace std; #define ll long long #define
  • 全选主元高斯-约旦法

    千次阅读 2014-11-13 15:15:44
    矩阵求逆的快速算法 ...矩阵求逆在3D程序中很常见,主要应用于求Billboard矩阵。...在需要大量Billboard矩阵...这里要介绍的矩阵求逆算法称为全选主元高斯-约旦法高斯-约旦法(全选主元)求的步骤如下: 首

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 228
精华内容 91
关键字:

高斯约旦法求逆矩阵