linearequationgroup.java

数学：数值分析：线性方程组 线性方程组的多种解法

package linearEquationGroup;

//*********************************************************************************************
//linearEquationGroup.java       Author: GaoXishan
//
//several different methods of solving a linear equation group(not finished).
//*********************************************************************************************

import java.text.DecimalFormat;

public class LinearEquationGroup {
	int n;// the number of the equation(also the number of the unknowns)
	private double[][] a;// the left matrix of the equation
	private double[] b;// the right value
	DecimalFormat fmt = new DecimalFormat("0.#####");

	// ----------------------------------------------------------------------------------------
	// Input the left matrix and the right value.
	// ----------------------------------------------------------------------------------------
	public LinearEquationGroup(int nInput, double aInput[][], double bInput[]) {
		n = nInput;
		a = aInput;
		b = bInput;
	}

	// ----------------------------------------------------------------------------------------
	// Confirm the equation group.
	// ----------------------------------------------------------------------------------------
	public String confirm() {
		String output = "\n";

		for (int i = 1; i < n + 1; i++)
			for (int j = 1; j < n + 2; j++)
				if (j == 1)
					output += "(" + fmt.format(a[i][j]) + "x1)";
				else if (j == n + 1)
					output += "=(" + fmt.format(b[i]) + ")\n";
				else
					output += "+(" + fmt.format(a[i][j]) + "x" + j + ")";

		return output;
	}

	// ----------------------------------------------------------------------------------------
	// Gauss elimination method.
	// ----------------------------------------------------------------------------------------
	public String gaussElimination() {
		double[][] u = new double[n + 1][n + 1], l = new double[n + 1][n + 1];
		double[] z = new double[n + 1], x = new double[n + 1];
		String output = "\n";

		// compute lij uij zi
		for (int i = 1; i < n + 1; i++)
			l[i][i] = 1;
		for (int i = 1; i < n + 1; i++)
			for (int j = 1; j < n + 1; j++)
				if (i > j) {
					double sum = 0;
					for (int k = 1; k < j; k++)
						sum += l[i][k] * u[k][j];
					l[i][j] = (a[i][j] - sum) / u[j][j];
				} else {
					double sum = 0;
					for (int k = 1; k < i; k++)
						sum += l[i][k] * u[k][j];
					u[i][j] = a[i][j] - sum;
				}
		for (int i = 1; i < n + 1; i++) {
			double sum = 0;
			for (int k = 1; k < i; k++)
				sum += l[i][k] * z[k];
			z[i] = b[i] - sum;
		}

		// compute xi
		for (int i = n; i > 0; i--) {
			double sum = 0;
			for (int k = i + 1; k < n + 1; k++)
				sum += u[i][k] * x[k];
			x[i] = (z[i] - sum) / u[i][i];
		}

		// output lij uij zi
		output += "\n\nthe chart is:\n";
		for (int i = 1; i < n + 1; i++)
			for (int j = 1; j < n + 2; j++)
				if (j == n + 1)
					output += "z" + i + "=(" + fmt.format(z[i]) + ")\n";
				else if (i > j)
					output += "l" + i + j + "=(" + fmt.format(l[i][j]) + ")   ";
				else
					output += "u" + i + j + "=(" + fmt.format(u[i][j]) + ")   ";

		// output xi
		output += "\n\nthe result is:\n";
		for (int i = n; i > 0; i--)
			output += "x" + i + "=(" + fmt.format(x[i]) + ")\n";

		return output;
	}

	// ----------------------------------------------------------------------------------------
	// Crout elimination method.
	// ----------------------------------------------------------------------------------------
	public String croutElimination() {
		double[][] u = new double[n + 1][n + 1], l = new double[n + 1][n + 1];
		double[] z = new double[n + 1], x = new double[n + 1];
		String output = "\n";

		// compute lij uij zi
		for (int i = 1; i < n + 1; i++)
			u[i][i] = 1;
		for (int i = 1; i < n + 1; i++)
			for (int j = 1; j < n + 1; j++)
				if (i < j) {
					double sum = 0;
					for (int k = 1; k < i; k++)
						sum += l[i][k] * u[k][j];
					u[i][j] = (a[i][j] - sum) / l[i][i];
				} else {
					double sum = 0;
					for (int k = 1; k < j; k++)
						sum += l[i][k] * u[k][j];
					l[i][j] = a[i][j] - sum;
				}
		for (int i = 1; i < n + 1; i++) {
			double sum = 0;
			for (int k = 1; k < i; k++)
				sum += l[i][k] * z[k];
			z[i] = (b[i] - sum) / l[i][i];
		}

		// compute xi
		for (int i = n; i > 0; i--) {
			double sum = 0;
			for (int k = i + 1; k < n + 1; k++)
				sum += u[i][k] * x[k];
			x[i] = z[i] - sum;
		}

		// output lij uij zi
		output += "\n\nthe chart is:\n";
		for (int i = 1; i < n + 1; i++)
			for (int j = 1; j < n + 2; j++)
				if (j == n + 1)
					output += "z" + i + "=(" + fmt.format(z[i]) + ")\n";
				else if (i > j)
					output += "l" + i + j + "=(" + fmt.format(l[i][j]) + ")   ";
				else
					output += "u" + i + j + "=(" + fmt.format(u[i][j]) + ")   ";

		// output xi
		output += "\n\nthe result is:\n";
		for (int i = n; i > 0; i--)
			output += "x" + i + "=(" + fmt.format(x[i]) + ")\n";

		return output;
	}

	// ----------------------------------------------------------------------------------------
	// Cholesky method,the method is only used to solve symmetry equation
	// group.
	// ----------------------------------------------------------------------------------------
	public String cholesky() {
		double[][] u = new double[n + 1][n + 1], l = new double[n + 1][n + 1];
		double[] z = new double[n + 1], x = new double[n + 1];
		String output = "\n";

		// whether the equation group is a symmetry equation group
		boolean sqJudge = true;
		for (int i = 1; i < n + 1; i++)
			for (int j = 1; j < n + 1; j++)
				if (a[i][j] != a[j][i])
					sqJudge = false;

		// begin to compute and output
		if (sqJudge == true) {
			// compute lij uij zi
			for (int j = 1; j < n + 1; j++)
				for (int i = 1; i < n + 1; i++)
					if (i > j) {
						double sum = 0;
						for (int k = 1; k < j; k++)
							sum += l[i][k] * u[k][j];
						l[i][j] = (a[i][j] - sum) / l[j][j];
					} else if (i == j) {
						double sum = 0;
						for (int k = 1; k < i; k++)
							sum += Math.pow(l[i][k], 2);
						u[i][j] = l[i][j] = Math.sqrt(a[i][j] - sum);
					} else
						u[i][j] = l[j][i];
			for (int i = 1; i < n + 1; i++) {
				double sum = 0;
				for (int k = 1; k < i; k++)
					sum += l[i][k] * z[k];
				z[i] = (b[i] - sum) / l[i][i];
			}

			// compute xi
			for (int i = n; i > 0; i--) {
				double sum = 0;
				for (int k = i + 1; k < n + 1; k++)
					sum += u[i][k] * x[k];
				x[i] = (z[i] - sum) / u[i][i];
			}

			// output lij uij zi
			output += "\n\nthe chart is:\n";
			for (int i = 1; i < n + 1; i++)
				for (int j = 1; j < n + 2; j++)
					if (j == n + 1)
						output += "z" + i + "=(" + fmt.format(z[i]) + ")\n";
					else if (i > j)
						output += "l" + i + j + "=(" + fmt.format(l[i][j])
								+ ")   ";
					else
						output += "u" + i + j + "=(" + fmt.format(u[i][j])
								+ ")   ";

			// output xi
			output += "\n\nthe result is:\n";
			for (int i = n; i > 0; i--)
				output += "x" + i + "=(" + fmt.format(x[i]) + ")\n";

			return output;
		} else
			return "the equation group is not a symmetry equation group,"
					+ "so it can't be solved by square root method\n";
	}

	// ----------------------------------------------------------------------------------------
	// Jacobi iterative method(input the error allowed and the initialized
	// value).
	// ----------------------------------------------------------------------------------------
	public String jacobiIterative(double errAllowed, double[] xIni) {
		double[][] g = new double[n + 1][n + 1];
		double[] f = new double[n + 1], x = new double[n + 1], xLast = new double[n + 1];
		String output = "\n";
		boolean convergent = true;

		// judge whether using this method is convergent(not right but useful)
		for (int i = 1; i < n + 1; i++)
			for (int j = 1; j < n + 1; j++)
				if (a[i][j] == 0)
					convergent = false;
		for (int i = 1; i < n + 1; i++) {
			double sum = 0;
			for (int j = 1; j < n + 1; j++)
				if (j != i)
					sum += Math.abs(a[i][j]);
			if (Math.abs(a[i][i]) <= sum)
				convergent = false;
		}

		if (convergent == true) {
			// compute the G matrix and the F vector then output them
			output += "\n\nthe G matrix is:\n";
			for (int i = 1; i < n + 1; i++)
				for (int j = 1; j < n + 1; j++) {
					if (i == j) {
						g[i][j] = 0;
						output += "g" + i + j + "=(" + fmt.format(g[i][j])
								+ ")   ";
					} else {
						g[i][j] = (-1) * a[i][j] / a[i][i];
						output += "g" + i + j + "=(" + fmt.format(g[i][j])
								+ ")   ";
						if (j == n)
							output += "\n";
					}
				}
			output += "\n\nthe F vector is:\n";
			for (int i = 1; i < n + 1; i++) {
				f[i] = b[i] / a[i][i];
				output += "f" + i + "=(" + fmt.format(f[i]) + ")   ";
			}

			// output the iterative formula
			output += "\n\nthe iterative formula is:\n";
			for (int i = 1; i < n + 1; i++)
				for (int j = 0; j < n + 2; j++)
					if (j == 0)
						output += "x" + i + "(k+1)=";
					else if (j == n + 1)
						output += "(" + fmt.format(f[i]) + ")\n";
					else
						output += "(" + fmt.format(g[i][j]) + "x" + j + "(k))+";

			// compute xi and output xi
			output += "\n\nthe result is:\n";
			double gNorm = Norm.matrixOne(n, g), xNorm = 0;
			int count = 0;
			for (int i = 1; i < n + 1; i++)
				xLast[i] = x[i] = xIni[i];
			do {
				for (int i = 1; i < n + 1; i++)
					output += "x" + i + "(" + count + ")=(" + fmt.format(x[i])
							+ ")\n";
				count++;
				output += "\n";
				for (int i = 1; i < n + 1; i++)