java实现求可逆矩阵使用单位矩阵拼接的形式

import java.text.DecimalFormat;

/**
 * 使用单位矩阵拼接的形式
 * @author imlilu
 *
 */
public class InverseMatrixSecond {

	/***
	 * 增广矩阵机型初等行变化的算法
	 * 
	 * @param value
	 *            需要算的增广矩阵
	 * @return 计算的结果
	 */
	public static double[][] mathDeterminantCalculation(double[][] value)
			throws Exception {
		// 当矩阵的行数大于2时
		for (int i = 0; i < value.length; i++) {
			// 检查数组对角线位置的数值是否是0，如果是零则对该数组进行调换，查找到一行不为0的进行调换
			if (value[i][i] == 0) {
				value = changeDeterminantNoZero(value, i, i);
			}
			for (int j = 0; j < i; j++) {
				// 让开始处理的行的首位为0处理为三角形式
				// 如果要处理的列为0则和自己调换一下位置，这样就省去了计算
				if (value[i][j] == 0) {
					continue;
				}
				// 如果要是要处理的行是0则和上面的一行进行调换
				if (value[j][j] == 0) {
					double[] temp = value[i];
					value[i] = value[i - 1];
					value[i - 1] = temp;
					continue;
				}
				double ratio = -(value[i][j] / value[j][j]);
				value[i] = addValue(value[i], value[j], ratio);
			}
		}
		return value;
	}

	/**
	 * 检查矩阵是否可逆
	 * 
	 * @param value
	 *            要检查的矩阵
	 * @return 矩阵的行列式的值
	 * @throws Exception
	 *             抛出的异常
	 */
	public static double mathDeterminantCalculationValue(double[][] value)
			throws Exception {
		value = mathDeterminantCalculation(value);
		DecimalFormat df = new DecimalFormat(".##");
		return Double.parseDouble(df.format(mathValue(value, 1)));
	}

	/**
	 * 计算行列式的结果
	 * 
	 * @param value
	 * @return
	 */
	public static double mathValue(double[][] value, double result)
			throws Exception {
		for (int i = 0; i < value.length; i++) {
			// 如果对角线上有一个值为0则全部为0，直接返回结果
			if (value[i][i] == 0) {
				return 0;
			}
			result *= value[i][i];
		}
		return result;
	}

	/***
	 * 将i行之前的每一行乘以一个系数，使得从i行的第i列之前的数字置换为0
	 * 
	 * @param currentRow
	 *            当前要处理的行
	 * @param frontRow
	 *            i行之前的遍历的行
	 * @param ratio
	 *            要乘以的系数
	 * @return 将i行i列之前数字置换为0后的新的行
	 */
	public static double[] addValue(double[] currentRow, double[] frontRow,
			double ratio) throws Exception {
		for (int i = 0; i < currentRow.length; i++) {
			currentRow[i] += frontRow[i] * ratio;
		}
		return currentRow;
	}

	/**
	 * 指定列的位置是否为0，查找第一个不为0的位置的行进行位置调换，如果没有则返回原来的值
	 * 
	 * @param determinant
	 *            需要处理的行列式
	 * @param line
	 *            要调换的行
	 * @param row
	 *            要判断的列
	 */
	public static double[][] changeDeterminantNoZero(double[][] determinant,
			int line, int row) throws Exception {
		for (int j = line; j < determinant.length; j++) {
			// 进行行调换
			if (determinant[j][row] != 0) {
				double[] temp = determinant[line];
				determinant[line] = determinant[j];
				determinant[j] = temp;
				return determinant;
			}
		}
		return determinant;
	}

	/**
	 * 将矩阵转化为单位阵和矩阵的拼接
	 * 
	 * @param inverseResult
	 *            需要转换的矩阵
	 */
	public static void changeMatixToUnit(double[][] inverseResult) {
		//将行和列都需要倒着进行运算
		for (int i = inverseResult.length - 1; i > -1; i--) {
			for (int j =  inverseResult.length -1; j > i-1; j--) {
				// 将需要修改的阶梯矩阵的前部分转换成为单位矩阵
				if (j  == i
						&& inverseResult[i][j] != 0) {
					double temp = inverseResult[i][j];
					// 当需要转换为单位阵的部分对角线上元素不为0的时候，整行除以这个数
					for (int j2 = 0; j2 < inverseResult[i].length; j2++) {
						inverseResult[i][j2] = inverseResult[i][j2] / temp;
					}
				} else {
					// 如果不是对角线上的元素时，找下面的那行乘以一个系数然后和当前行的元素相加，变为0
					for (int j2 = 1; j2 < inverseResult.length-j+2; j2++) {
						if (inverseResult[i+j2][j] != 0) {
							double temp = inverseResult[i][j]
									/ inverseResult[i+j2][j];
							for (int k = 0; k < inverseResult[i].length; k++) {
								inverseResult[i][k] -= (inverseResult[i+j2][k] * temp);
							}
							break;
						}
					}
				}
			}
		}
	}

	public static void main(String[] args) {
//		double[][] test = { { 2, 1, 1 }, { 3, 1, 2 }, { 1, -1, 0 } };
//		 double[][] test = {{3,-2,0,0},{5,-3,0,0},{0,0,3,4},{0,0,1,1}};
		 double[][] test =
		 {{0,0,0,1,2},{0,0,0,2,3},{1,1,0,0,0},{0,1,1,0,0},{0,0,1,0,0}};
		double result;
		try {
			// 将二维数组中的元素添加上等量的单位矩阵
			double[][] temp = new double[test.length][test[0].length * 2];
			// 在矩阵后边补加上单位矩阵
			for (int i = 0; i < test.length; i++) {
				for (int j = 0; j < temp[i].length; j++) {
					if (j < test[i].length) {
						temp[i][j] = test[i][j];
					} else if (j - test[i].length == i) {
						temp[i][j] = 1;
					} else {
						temp[i][j] = 0;
					}
				}
			}
			// 先计算矩阵的行列式的值是否等于0，如果不等于0则该矩阵是可逆的
			result = mathDeterminantCalculationValue(test);
			if (result == 0) {
				System.out.println("矩阵不可逆");
			} else {
				System.out.println("矩阵可逆");
				// 转换成阶梯矩阵
				double[][] inverseResult = mathDeterminantCalculation(temp);
				changeMatixToUnit(inverseResult);
				//去除前面的单位矩阵后
				DecimalFormat df = new DecimalFormat(".##");
				for (int i = 0; i < test.length; i++) {
					for (int j = 0; j < test[i].length; j++) {
						test[i][j] = Double.parseDouble(df.format(inverseResult[i][j+test.length]));
					}
				}
				// 将阶梯矩阵中的前部分转化为单位阵。
				
				for (int i = 0; i < test.length; i++) {
					for (int j = 0; j < test[i].length; j++) {
						System.out.print(test[i][j] + "    ");
					}
					System.out.println();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("不是正确的行列式！！");
		}
	}

}