分治法

package com.zhp.first;

/**
 * 高斯消去法和LU分解
 */
public class GSLU {
	public static final int U = 0;
	public static final int L = 1;

	public static void main(String[] args) {

		/*
		 * 解为： 
		  x = 1, y = 0, z = -1 
		 * 方程组： 
		  2x - y + z = 1 
		  4x + y - z = 5 
		  x + y + z = 0
		 * 正确结果： 
		  4.0  1.0  -1.0  5.0 
		  0.0  -1.5  1.5  -1.5 
		  0.0  0.0  2.0  -2.0
		 */

		double[][] A = new double[][] { { 2, 1, 0, 0 }, { 1, 0, 0, 1 }, { 0.5, 0.5, 1, 0 } };

		double[][] U = new double[A.length][A.length];
		U = Elimi(A, 0);
		double[][] L = new double[A.length][A.length];
		L = Elimi(A, 1);

		System.out.println("矩阵U：");
		Tools.showArray(U);
		System.out.println("矩阵L：");
		Tools.showArray(L);
	}

	/**
	 * mode = 0, U； mode = 1, L;
	 */
	public static double[][] Elimi(double[][] array, int mode) {

		// 复制一个数组作为原数组a
		double[][] a = new double[array.length][array[0].length];
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[0].length; j++) {
				a[i][j] = array[i][j];
			}
		}

		int row = a.length; // 行数
		double[][] L = new double[row][row];

		// 把矩阵L的上三角赋值为0
		for (int i = 0; i < row; i++) {
			for (int j = i + 1; j < row; j++) {
				L[i][j] = 0;
			}
		}
		// 把矩阵L的对角线赋值为1
		for (int i = 0; i < row; i++) {
			L[i][i] = 1;
		}

		for (int i = 0; i < row; i++) {
			int pivotrow = i;

			// 找出当前列绝对值最大的数在哪一行（设为M）。 这是 “最大选主元法”
			for (int j = i + 1; j < row; j++) {
				if (Math.abs(a[j][i]) > Math.abs(a[pivotrow][i])) {
					pivotrow = j;
				}
			}

			// 把刚才找到的最大行（M）,和当前行对调
			for (int k = i; k < a[i].length; k++) {
				double temp = a[i][k];
				a[i][k] = a[pivotrow][k];
				a[pivotrow][k] = temp;
			}

			for (int j = i + 1; j < row; j++) {
				double scale = a[j][i] / a[i][i]; // 前面的步骤已经保证比值肯定小于1
				L[j][i] = scale;
				for (int k = i; k < a[i].length; k++) {
					/*
					 * 该行第一个变为零，右侧元素按比例缩放 当前元素 = 当前元素-最大值*比例
					 */
					a[j][k] = a[j][k] - a[i][k] * scale;
				}
			}
		}

		if (mode == 0) {
			return a;
		} else {
			return L;
		}

	}

}

package com.zhp.first;

/**
 * 这是一个工具类
 */
public class Tools {

	public static void main(String[] args) {
		double[][] M = { { 1, 0, 0 }, { 2, 1, 0 }, { 0.5, 0.5, 1 } };
		double[] b = { 1, 5, 0 };
		double[] a = getA(M, b);
		System.out.println("解为：");
		showArray2(a);

	}

	/**
	 * 得到一个上三角矩阵的线性方程组的解 U is the up-triangle matrix
	 */
	public static double[] getAnswer(double[][] U) {
		int row = U.length;
		int col = U[0].length;

		// 保存答案的数组
		double[] a = new double[row];

		// 获得最后一个答案
		a[row - 1] = U[row - 1][col - 1] / U[row - 1][col - 2];

		// 获得其他所有答案
		for (int i = row - 2; i >= 0; i--) {
			int start = i + 1;
			int end = col - 2;
			double sum = 0;
			for (int j = start; j <= end; j++) {
				sum += a[j] * U[i][j];
			}
			a[i] = (U[i][col - 1] - sum) / U[i][i];
		}
		return a;
	}

	/**
	 * [M][a] = [b] M 为一个行列式 a 是一个列向量 b 是一个列向量 求 a; 方法返回a；
	 */
	public static double[] getA(double[][] M, double[] b) {
		double[] a = new double[b.length];
		if (M.length != b.length) {
			System.out.println("getA() 参数异常，M的行必须和b的行数相同");
			return a;
		}

		double[][] tem = new double[M.length][M.length + 1];
		for (int i = 0; i < M.length; i++) {
			for (int j = 0; j < M[0].length; j++) {
				tem[i][j] = M[i][j];
			}
		}
		for (int i = 0; i < b.length; i++) {
			tem[i][tem[i].length - 1] = b[i];
		}

		double[][] U = GSLU.Elimi(tem, GSLU.U);

		a = getAnswer(U);

		return a;
	}

	/** 输出一个二维数组 */
	public static void showArray(double[][] a) {
		for (int i = 0; i < a.length; i++) {
			for (double tem : a[i]) {
				System.out.print(tem + "\t");
			}
			System.out.println();
		}
	}

	/** 输出一个一位数组 */
	public static void showArray2(double[] a) {
		for (double tem : a) {
			System.out.print(tem + "\t");
		}
	}

}

package com.zhp.first;

/**
 * 这个类是求矩阵的逆的
 */
public class Inverse {

	public static void main(String[] args) {
		
		double[][] A = new double[][] { { 1, 0, 1 }, { 0, 1, 0 }, { 1, 0, 1 } };
		double[][] NI = getNi(A);
		Tools.showArray(NI);
	}

	/**
	 * 求矩阵的逆
	 * 该方法并没有检测矩阵是否是非退化的矩阵
	 * 使用时若传入一个没有逆矩阵的矩阵，得到的结果是有误的
	 */
	public static double[][] getNi(double[][] a) {
		int row = a.length;
		int col = a[0].length;

		if (row != col) {
			System.out.println("矩阵的行列数不相等，没有逆矩阵！");
		}

		// 复制一下a
		double[][] A = new double[row][col];
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[0].length; j++) {
				A[i][j] = a[i][j];
			}
		}

		// 这里保存的是逆矩阵
		double[][] NI = new double[col][row];

		//	获得U和L
		double[][] U = GSLU.Elimi(A, GSLU.U);
		double[][] L = GSLU.Elimi(A, GSLU.L);

		System.out.println("L:");
		Tools.showArray(L);
		System.out.println("-----------------\n");

		// [U][Bi]=[Ii]
		double[] Bi = new double[NI.length];
		double[][] B = new double[Bi.length][row];

		// LU A' = I >> LB = I
		for (int i = 0; i < NI[0].length; i++) {
			double[] b = new double[NI.length];
			b[i] = 1;
			Bi = Tools.getA(L, b);

			System.out.println("Bi:");
			Tools.showArray2(Bi);
			System.out.println("\n-----------------\n");

			System.out.println("b:");
			Tools.showArray2(b);
			System.out.println("\n----------------\n");

			for (int j = 0; j < NI.length; j++) {
				B[j][i] = Bi[j];
			}
		}

		// UA' = B
		for (int i = 0; i < B[0].length; i++) {
			double[] b = new double[B.length];
			for (int j = 0; j < b.length; j++) {
				b[j] = B[j][i];
			}

			Bi = Tools.getA(U, b);

			System.out.println("b:");
			Tools.showArray2(b);
			System.out.println("\n----------------\n");

			for (int j = 0; j < NI.length; j++) {
				NI[j][i] = Bi[j];
			}
		}

		System.out.println("逆矩阵为：");
		Tools.showArray(NI);
		System.out.println("------------------");

		return NI;
	}
}