设要求出n阶矩阵A的逆矩阵B。

对于一个矩阵的初等行变换，有三种： 

1. 交换两行。 

2. 将某一行的所有元素乘以一个非零实数k。 

3. 将某一行j，加上某一行i(i≠j)乘以一个非零实数k，即Aj=Aj+Ai∗k。

可以发现的是，每种变换其实都可以等价于乘以某个矩阵，事实上称其为初等矩阵。

那么，当我们不停地对A进行初等变换，并且用另外一个矩阵C不停地乘上这种变换对应的初等矩阵，那么当A变为I(单位矩阵)时，C就是A的逆矩阵了。 

怎么样将A变为I？我们类似于高斯消元一样，一行一行一列一列地扫过去。由于最终要保证Ai,i=1，其他为0。 

设当前扫到第i行，那么对于Ai,1∼i−1=0。但是对于j<i，Aj,i可能不等于0。但我们初等变换中可以先对第i行除以Ai,i，即保证Ai,i=1，接着用i整行去消j<i。那么Aj,i就等于0了。那么我们这样一行一行地消下去即可。我们对A中做的所有操作，顺便对C同时做就好了。反正都是乘上同一个矩阵。

一开始没有操作时C就是I。

最后我们用O(N3)的复杂度求出了逆矩阵。

高等代数的理论知识
(A | E) 经过初等行变换（E | A-1）（A-1 代表A的逆）
matrix_inv <- function(A)
{
  A_zhi <- Matrix::rankMatrix(A)[1]
  n_row <- dim(A)[1]
  n_col <- dim(A)[2]
  if((n_col==n_row)&(n_row == A_zhi))
  {
    B <- diag(1,n_col)
    col_index <- 1
    for(row_index in 1:(n_row - 1))
    {
      temp_col <- A[col_index:n_row,col_index]
    
      non_zreo_row <- which(temp_col!=0)[1]
      #一定找出当前行第一个元素不为零
      temp_row <- A[col_index,]
      A[col_index,] <- 
        A[col_index + non_zreo_row - 1,]
      A[col_index + non_zreo_row - 1,] <- temp_row 
      temp_row1 <- B[col_index,]
      B[col_index,] <- 
        B[col_index + non_zreo_row - 1,]
      B[col_index + non_zreo_row - 1,] <- temp_row1
      #其余的元素化零
      for(j in (col_index + 1):n_row)
      {
        temp_number <-
          A[j,col_index]/A[col_index,col_index]
        A[j,] <- A[j,] - A[col_index,]*  temp_number
        B[j,] <- B[j,] - B[col_index,]* temp_number
      }
      col_index <- col_index + 1
    }
    #此是的A时候一个上三角,接下来化为对角矩阵
    col_index <- n_col
    for(row_index in n_row:2)
    {
      for(j in (col_index - 1):1)
      {
        temp_number <-  
          A[j,col_index]/A[col_index,col_index]
        A[j, ] <- A[j, ] - A[col_index,] *  
          temp_number
        B[j,] <- B[j,] - B[col_index,] *
          temp_number
      }
      col_index <- col_index - 1
    }
    #此是的A时候一个对角矩阵,接下来化为对角矩阵
    #标准化
    for(i in 1:n_col)
    {
      B[i,] <- B[i,]/A[i,i]
    }
    return(MASS::fractions(B))
  }
  else
  {
    print("输入的矩阵无法求逆")
  }
}

matrix_inv(A)
 [,1] [,2] [,3]
[1,]  1    0   -1  
[2,] -1    1    1  
[3,]  0    0    1 

006 逆矩阵的求法（矩阵初等行变换）

package gaodai.matrix;
import gaodai.determinant.DeterminantCalculation;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* 矩阵求逆(初等行变换)
* @author 邱万迟
*
*/
public class InverseOfMatrix {
private List> matrix;
private int lineNum;
private int columnNum;
public InverseOfMatrix(List> data){
matrix = data;
lineNum = data.size();
columnNum = data.get(0).size();
}
public void caculate() throws Exception{
//1.非方正不能求逆
//2.方正的行列式值为零不能求逆
if( lineNum != columnNum){
throw new Exception("此矩阵不能求逆>>>>>>>>>>>>>>>>>");
}
List> tempList = new ArrayList>();
for(List l : matrix){
List newList = new ArrayList();
newList.addAll(l);
tempList.add(newList);
}
DeterminantCalculation d = new DeterminantCalculation(tempList);
d.chang2UpperTriangle();
double result = d.getValue();
if(result == 0){
throw new Exception("此矩阵不能求逆>>>>>>>>>>>>>>>>>");
}
//增加单位矩阵
for(int i = 0; i < lineNum; i++){
List list = matrix.get(i);
for(int j = 0; j < columnNum; j++){
if(i == j){
list.add(1.0);
}else{
list.add(0.0);
}
}
}
print();
chang2UpperTriangle();//化为上三角
changeReducedMatrix();//化为约化矩阵
print();
}
public void getValue(){
boolean flag = true;
for(int i = 0; i < lineNum; i++){
if(matrix.get(i).get(i) == 0){
flag = false;
}
if(!flag){
break;
}
}
if(!flag){
System.out.println("此矩阵不可逆>>>>>>>>>>>>>>");
}else{
for(int i = 0; i < lineNum; i++){
List list = matrix.get(i);
for(int j = 0; j < columnNum; j++){
list.remove(0);
}
}
System.out.println("逆矩阵为>>>>>>>>>>>>>>>>>");
print();
}
}
/**
* 打印
*/
public void print() {
int i = 0, j = 0;
for (List line : matrix) {
for (double element : line) {
System.out.print(element);
System.out.print("(" + i + "," + j + ")  ");
System.out.print("  ");
j++;
}
System.out.println();
i++;
j = 0;
}
System.out.println();
}
/**
* 校验是否是上三角，不是就的继续计算
*
* @return
*/
public boolean isCaculate() {
boolean hasCaculate = false;
for (int i = 0; i < matrix.size(); i++) {
for (int j = 0; j < i; j++) {
if (matrix.get(i).get(j) != 0.0) {
System.out.println("(" + (i + 1) + "," + (j + 1) + ")元素值不为零");
hasCaculate = true;
break;
}
}
if (hasCaculate) {
break;
}
}
return hasCaculate;
}
private int caculateTimes;
/**
* 化为上三角
* @throws Exception
*/
public void chang2UpperTriangle() throws Exception {
if (!isCaculate()) {
return;
}
int min = lineNum;
caculateTimes++;
System.out.println("--------------第" + caculateTimes + "次计算--------------");
for (int i = 0; i < min; i++) {
for (int j = i + 1; j < min; j++) {
double multiplyNum = -1 * matrix.get(j).get(i) / matrix.get(i).get(i);
if (multiplyNum == 0) {
continue;
}
this.lineMultiplyNumAdd2OtherLine(multiplyNum, (i + 1), (j + 1));
print();
}
}
print();
chang2UpperTriangle();
}
/**
* 变为约化矩阵
*/
public void changeReducedMatrix() throws Exception{
for(int i = 0; i < lineNum; i++){//行
if(i == 0){
//continue;
}
List temp = matrix.get(i);
for(Double d : temp){
if(d == 0){
continue;
}
double multiplyNum = 1.0 / d;
for(int a = 0; a < temp.size(); a++){
temp.set(a, temp.get(a) * multiplyNum);
}
break;
}
print();
for(int j = 0; j <= columnNum; j++){//列
if(temp.get(j) != 0){//这个数不为零 ，此数为第 i行第j列
for(int t = 0; t < lineNum; t++){//行
if(t == i || matrix.get(t).get(j) == 0){//本列的其他行
continue;
}
double multiplyNum = -1 * matrix.get(t).get(j) / temp.get(j);
this.lineMultiplyNumAdd2OtherLine(multiplyNum, (i + 1), (t + 1));
print();
}
break;
}
}
}
}
/**
* 第a行乘以number 加到第b行上
* @param number 乘以的数
* @param a行号
* @param b行号
* @throws Exception
*/
public void lineMultiplyNumAdd2OtherLine(double number, int a, int b) throws Exception {
if (a < 1 || a > matrix.size() || b < 1 || b > matrix.size()) {
throw new Exception("输入的行号不合法");
}
List aLine = matrix.get(a - 1);
List bLine = matrix.get(b - 1);
for (int i = 0; i < bLine.size(); i++) {
double temp = bLine.get(i) + aLine.get(i) * number;
bLine.set(i, temp);
}
System.out.println("第" + a + "行乘以" + number + "加到第" + b + "行:");
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入矩阵的行数与列数,用逗号分隔:");
String sn = scanner.next();
String[] snArr = sn.split(",");
int lineNum = Integer.valueOf(snArr[0]);
int columnNum = Integer.valueOf(snArr[1]);
List> matrix = new ArrayList>();
for(int i = 0; i < lineNum; i++){
System.out.println("请输入第" + (i + 1) + "行的数,用逗号分隔:");
String lineData = scanner.next();
String[] lineDataArr = lineData.split(",");
List line = new ArrayList();
matrix.add(line);
for(int j = 0; j < columnNum; j++){
line.add(Double.valueOf(lineDataArr[j]));
}
}
InverseOfMatrix m = new InverseOfMatrix(matrix);
m.print();
try {
m.caculate();
m.getValue();
} catch (Exception e) {
e.printStackTrace();
}
}
}