matrix.java

一些常用的java程序,包括swing.net.io,matrix等

package mymath;

public class Matrix {
	int [][] matrix;
	int RowDim;
	int LineDim;
	/**
	 * the matrix Rows from 0, 1... RowDim-1.
	 * Line from 0, 1...LineDim-1.
	 */
	
	public Matrix(int m, int n){
		RowDim = m;
		LineDim = n;
		matrix = new int[RowDim][LineDim];
		for(int i = 0; i < RowDim; i++)
			for(int j = 0; j < LineDim; j++)
				matrix[i][j] = 0;
		//matrix[i][j] i must < RowDim, j must < LineDim 
	}//Matrix(int m, int n)
	
	/**
	 * i,j begin from 0
	 * @param value
	 */
	public void setValue(int i, int j, int value)	{
		try{
			matrix[i][j] = value;
		}
		catch(Exception e){
			System.err.println("setValue(i,j,value) exception");
			this.outputMatrix();
			out("i == "+i+"\tj == "+j+"\tvalue == "+value);
		}
	}//setValue(int i, int j, int value)
	
	/**
	 * src and dst begin from 0, src[i],dst[i] begin from 0
	 */
	public void addArc(int []src, int [] dst ){
		if(src.length != dst.length){
			System.err.println("addArc(): src.length != dst.length, fail addArc");
			System.exit(0);
		}
		
		for(int i = 0; i < src.length; i++){
			setValue(src[i], i, 1);
			setValue(dst[i], i, -1);
		}			
	}//addArc(int []src, int [] dst )
	
	
	public Matrix copyMatrix(){
		Matrix mt = new Matrix(this.RowDim, this.LineDim);
		
		for(int i = 0; i < this.RowDim; i++)
			for(int j = 0; j < this.LineDim; j++){
				mt.matrix[i][j] = this.matrix[i][j];
			}
		
		return mt;
	}//copyMatrix()
	
	
	/**
	 * 
	 * @return inverse matrix imt, which means imt * mt = E
	 */
	public Matrix getInverseMatrix(){
		if(LineDim != RowDim){
			System.err.println("getInverseMatrix(mt): RowDim != LineDim");
			out("(RowDim = "+RowDim+" != (LineDim = "+LineDim+")");
			System.exit(0);
		}
		Matrix imt = new Matrix(RowDim, LineDim);
		
		return imt;		
	}//getInverseMatrix()
	
	//public Matrix 
	
	/**
	 * 
	 * @param xindex -- row index
	 * @param yindex -- line index
	 * @return matrix delete Row xindex and Line yindex
	 */
	public int getComplementMinor(int xindex, int yindex){
		Matrix mt = this.copyMatrix();		
		
		mt = mt.deleteRow(xindex);
		mt = mt.deleteLine(yindex);
		return mt.getDeterminant();
	}
	
	/**
	 * 
	 * @return InvertedMatrix, which means matrix(m,n),then we get matrix(n,m)
	 * 										matrix[m][n] = imatrix[n][m]
	 */
	public Matrix getInvertedMatrix() {
		Matrix imfg = new Matrix(this.LineDim, this.RowDim);
		for (int i = 0; i < this.RowDim; i++)
			for (int j = 0; j < this.LineDim; j++) {
				imfg.matrix[j][i] = matrix[i][j];
			}

		return imfg;
	}//getInvertedMatrix()
	
	/**
	 * 
	 * @return the matrix's Determinant, which means |matrix|
	 */
	public int getDeterminant() {
		if (this.LineDim != this.RowDim) {
			return 0;
		}

		if (this.LineDim == 3) {
			int sum = 0;
			int[][] a = this.matrix;
			sum = a[0][0] * a[1][1] * a[2][2] + a[0][1] * a[1][2] * a[2][0]
					+ a[0][2] * a[1][0] * a[2][1] - a[0][2] * a[1][1] * a[2][0]
					- a[0][1] * a[1][0] * a[2][2] - a[0][0] * a[1][2] * a[2][1];
			//out("Dim == 3, return " + sum);
			return sum;
		}

		else if (this.LineDim == 2) {
			int sum = 0;
			int[][] a = this.matrix;

			sum = a[0][0] * a[1][1] - a[0][1] * a[1][0];
			return sum;
		}

		else if (this.LineDim == 1) {
			return this.matrix[0][0];
		}

		else {// System.err.println("interitor: because of this.RowDim = "+this.RowDim);
			int a[][] = this.matrix;
			Matrix temp = this;
			int sum = 0;

			// Mattrix temp2 = this.CopyMatrix();

			for (int i = 0; i < this.RowDim; i++) {
				if (a[i][0] != 0) {
					temp = this.deleteRow(i);
					temp = temp.deleteLine(0);
					//System.out.println("the matrix was Divided at a[" + i+ "][0]");
					//System.out.println("a[" + i + "][0] = " + a[i][0]);
					//temp.outputMatrix();
					if (i % 2 == 0)
						sum += a[i][0] * temp.getDeterminant();
					else
						sum -= a[i][0] * temp.getDeterminant();

				}// if
			}// for
			return sum;
		}// else
	}//getDeterminant()
	
	public Matrix deleteLine(int lineindex) {
		if (lineindex >= this.LineDim) {
			System.err.println("deletLine(): lineindex >= this.LineDim");
			System.exit(0);
		}

		Matrix ithis = new Matrix(this.RowDim, this.LineDim - 1);
		for (int i = 0; i < this.RowDim; i++)
			for (int j = 0; j < this.LineDim - 1; j++) {
				if (j >= lineindex)
					ithis.matrix[i][j] = this.matrix[i][j + 1];
				else
					ithis.matrix[i][j] = this.matrix[i][j];
			}
		return ithis;
	}//Matrix deleteLine(int lineindex)

	public Matrix deleteRow(int rownumber) {
		if (rownumber >= this.RowDim) {
			out("RowDim = " + this.RowDim);
			out("rownum = " + rownumber);
			System.err.println("deletRow(): rownumber >= this.RowDim");
			System.exit(0);
		}

		Matrix ithis = new Matrix(this.RowDim - 1, this.LineDim);

		for (int i = 0; i < this.RowDim - 1; i++)
			for (int j = 0; j < this.LineDim; j++) {
				if (i >= rownumber)
					ithis.matrix[i][j] = this.matrix[i + 1][j];
				else
					ithis.matrix[i][j] = this.matrix[i][j];
			}
		return ithis;
	}//deleteRow(int rownumber)

	/**
	 * 
	 * 
	 * @return
	 */
	public Matrix changeValue(int oldval, int newval){
		Matrix mt = copyMatrix();
		for(int i = 0; i < RowDim; i++)
			for(int j = 0; j < LineDim; j++){
				if(mt.matrix[i][j] == oldval){
					mt.matrix[i][j] = newval;
				}
			}
		return mt;
	}

	public static Matrix MultiplicationOfMatrix(Matrix left, Matrix right) {
		if (left.RowDim != right.LineDim) {
			System.err
					.println("MultiplicationOfMatrix(): left.RowDim != right.LineDim");
			System.exit(0);
		}
		
		// n * m -multiplication m * k = n * k
		Matrix mfg = new Matrix(left.RowDim, right.LineDim);
		for (int j = 0; j < left.RowDim; j++)
			for (int i = 0; i < right.LineDim; i++) {
				for (int k = 0; k < left.LineDim; k++) {
					mfg.matrix[j][i] += left.matrix[j][k] * right.matrix[k][i];
				}
			}
		
		mfg.outputMatrix("the result of multiplication");
		return mfg;
	}//Matrix MultiplicationOfMatrix(Matrix left, Matrix right)

	public void outputMatrix(String msg)
	{
		System.out.println("-------------------MatrixInfomation-------------------------");
		System.err.println(msg);
		for(int i = 0; i < RowDim; i++){
			for(int j = 0; j < LineDim; j++){
				if(matrix[i][j] >= 0) System.out.print(" | "+matrix[i][j]);
				else System.out.print(" |"+matrix[i][j]);
			}//j
			System.out.println(" |");
		}//i

		System.out.println("RowDim = "+RowDim);
		System.out.println("LineDim = "+LineDim);
		System.out.println("===================MatrixInfomation=========================");
	}//outputMatrix()
	public void outputMatrix()
	{
		System.out.println("-------------------MatrixInfomation-------------------------");
		
		for(int i = 0; i < RowDim; i++){
			for(int j = 0; j < LineDim; j++){
				if(matrix[i][j] >= 0) System.out.print(" | "+matrix[i][j]);
				else System.out.print(" |"+matrix[i][j]);
			}//j
			System.out.println(" |");
		}//i

		System.out.println("RowDim = "+RowDim);
		System.out.println("LineDim = "+LineDim);
		System.out.println("===================MatrixInfomation=========================");
	}//outputMatrix()
	
	public void out(String msg){
		System.out.println(msg);
	}//out(String msg)
}