matrix.java

用JAVA所写的用于矩阵运算的类

package com.lc.v3.scm.datamining.math;

/*****************************************************************************
 * @author leitw
 *
 *  at Taian - Shandong province ,China
 *  corporation langchao Group
 *  20/4/2005
 *****************************************************************************/

/*******************************************************************************
 * this class include the basic construct function ,get or set function and so
 * on for matrix use
 ******************************************************************************/

public class Matrix {
	private double[][] matrix = null;

	private int length = 0;

	private int width = 0;

	/*
	 * construct function
	 */
	public Matrix(int i, int j) {
		if ((i <= 0) || (j <= 0)) {
		//	System.out.println("\n构造函数 The parameter is not legal");
			return;
		}
		length = i;
		width = j;
		matrix = new double[length][width];
		for (int m = 0; m < length; m++)
			for (int n = 0; n < width; n++)
				matrix[m][n] = 0;
	}

	//设置第i行第j列元素
	public void setElement(double data, int i, int j) {
		if ((i < 1) || (j < 1) || (i > length) || (j > width)) {
			//System.out.println("\n设置第i行第j列元素 The parameter is unnormal");
			return;
		}
		matrix[i - 1][j - 1] = data;

	}

	//获得第i行第j列元素
	public double getElement(int i, int j) {
		return matrix[i - 1][j - 1];
	}

	//获得阵长
	public int length() {
		return length;
	}

	//获得阵宽
	public int width() {
		return width;
	}

	//设置阵长
	public void setLength(int len) {
		if (len <= 0) {
		//	System.out.println("\n设置阵长 The length is legal");
			return;
		}
		length = len;
	}

	//设置阵宽
	public void setWide(int wid) {
		if (wid <= 0) {
		//	System.out.println("\n设置阵宽 The width is not legal");
			return;
		}
		width = wid;
	}

	//获得矩阵的第row行
	public double[] getRow(int row) {
		if ((row > length) || (row < 1)) {
		//	System.out.println("\n获得矩阵的第row行 parameter error");
			return null;
		}
		double[] temp = matrix[row - 1];
		return temp;
	}

	//获得矩阵的第col列
	public double[] getCol(int col) {
		if ((col > width) || (col < 1)) {
			// System.out.println("\n获得矩阵的第col列 parameter error");
			return null;
		}
		double[] temp = matrix[col - 1];
		for (int i = 0; i < length; i++)
			temp[i] = matrix[i][col - 1];
		return temp;
	}

	//设置矩阵第row行
	public void setRow(double[] data, int row) {
		if ((row < 1) || (row > length)) {
			//System.out.println("\n设置矩阵第row行 parameter error");
			return;
		}
		int len = data.length;
		if (len != width) {
		//	System.out.println("\n设置矩阵第row行 The data is not normal");
			return;
		}
		for (int i = 0; i < width; i++)
			matrix[row - 1][i] = data[i];
	}

	//设置矩阵第col列
	public void setCol(double[] data, int col) {
		if ((col < 1) || (col > width)) {
		//	System.out.println("\n设置矩阵第col列 parameter error");
			return;
		}
		int len = data.length;
		if (len != length) {
		//	System.out.println("\n设置矩阵第col列 The data is not normal");
			return;
		}
		for (int i = 0; i < length; i++)
			matrix[i][col - 1] = data[i];
	}

	//矩阵交换两行
	public void chgRow(int chgfrom, int chgto) {
		//double[] temp = null;
		if ((chgfrom > length) || (chgto > length) || (chgfrom < 1)
				|| (chgto < 1)) {
		//	System.out.println("\n矩阵交换两行 parameter error");
			return;
		}
		double[] temp = new double[width];
		for (int i = 0; i < width; i++) {
			temp[i] = matrix[chgfrom - 1][i];
			matrix[chgfrom - 1][i] = matrix[chgto - 1][i];
			matrix[chgto - 1][i] = temp[i];
		}
	}

	//矩阵交换两列
	public void chgCol(int chgfrom, int chgto) {
		if ((chgfrom > width) || (chgto > width) || (chgfrom < 1)
				|| (chgto < 1)) {
		//	System.out.println("\n parameter error");
			return;
		}
		double[] temp = new double[length];
		for (int i = 0; i < length; i++) {
			temp[i] = matrix[i][chgfrom - 1];
			matrix[i][chgfrom - 1] = matrix[i][chgto - 1];
			matrix[i][chgto - 1] = temp[i];
		}
	}

	//矩阵求和,-1:失败；1：成功
	public int add(Matrix matrixAdd) {
		int lengthAdd = matrixAdd.length;
		int widthAdd = matrixAdd.width;
		if ((lengthAdd != this.length) || (widthAdd != this.width)) {
			//System.out.println("THe parameter is wrong,two Matrix can not do add operation");
			return -1;
		}
		double[][] matrixData = new double[lengthAdd][widthAdd];
		matrixData = matrixAdd.matrix;
		for (int i = 0; i < this.length; i++)
			for (int j = 0; j < this.width; j++) {
				matrix[i][j] = matrix[i][j] + matrixData[i][j];
			}
		return 1;
	}

	//矩阵求和
	public int add(double[][] matrixAdd) {
		double[] sap = matrixAdd[0];
		if(matrixAdd.length<this.length||sap.length<this.width){
			return -1;		
		}
		for (int i = 0; i < this.length; i++)
			for (int j = 0; j < this.width; j++) {
				matrix[i][j] = matrix[i][j] + matrixAdd[i][j];
			}
		return 1;
	}

	
//	矩阵求差
	public int subtract(Matrix matrixAdd) {
		int lengthAdd = matrixAdd.length;
		int widthAdd = matrixAdd.width;
		if ((lengthAdd != this.length) || (widthAdd != this.width)) {
			//System.out.println("THe parameter is wrong,two Matrix can not do add operation");
			return -1;
		}
		double[][] matrixData = new double[lengthAdd][widthAdd];
		matrixData = matrixAdd.matrix;
		for (int i = 0; i < this.length; i++)
			for (int j = 0; j < this.width; j++)
			{
				matrix[i][j] = matrix[i][j] - matrixData[i][j];
			}
		return 1;
	}

	//矩阵求差
	public int subtract(double[][] matrixAdd) {
		double[] sap = matrixAdd[0];
		if(matrixAdd.length<this.length||sap.length<this.width){
			return -1;		
		}

		for (int i = 0; i < this.length; i++)
			for (int j = 0; j < this.width; j++) {
				matrix[i][j] = matrix[i][j] - matrixAdd[i][j];
			}
		return 1;
	}

	/*
	 * 
	 * 两个矩阵相乘
	 * */
	public static Matrix multiply(Matrix matrix1, Matrix matrix2) {
		Matrix ResultMul = null;
		int length1 = matrix1.length();
		int width1 = matrix1.width();
		int length2 = matrix2.length();
		int width2 = matrix2.width();
		if ((length1 <= 0)
			|| (length2 <= 0)
			|| (width1 <= 0)
			|| (width2 <= 0)
			|| (width1 != length2)) {
			// System.out.println("\n两个矩阵相乘 The compute is not legal");
			return null;
		}
		ResultMul = new Matrix(length1,width2);
		for (int i = 1; i <= length1; i++) {
			for (int j = 1; j <= width2; j++) {
				double temp = 0;
				for (int k = 1; k <= width1; k++) {
					temp = temp + matrix1.getElement(i, k) * matrix2.getElement(k, j);
				}
				ResultMul.setElement(temp, i, j);
			}
		}
		return ResultMul;
	}
	
	
	/*
	 * 
	 * 矩阵的转置
	 * */
	public static Matrix turn(Matrix matrix1) {
		Matrix ResultTurn = null;
		int len = matrix1.length();
		int wid = matrix1.width();
		if ((len <= 0) || (wid <= 0)) {
			//System.out.println("\n矩阵的转置 The matrix is not legal");
			return null;
		}
		ResultTurn = new Matrix(wid,len);
		ResultTurn.setLength(wid);
		ResultTurn.setWide(len);
		for (int i = 1; i <= wid; i++) {
			for (int j = 1; j <= len; j++) {
				double temp = matrix1.getElement(j, i);
				ResultTurn.setElement(temp, i, j);
			}
		}
		return ResultTurn;
	}

	/*
	 * 
	 * 矩阵求逆（线性变换法）
	 * */
	 public static Matrix rev(Matrix matrix){
		 int len = matrix.length();
		 int wid = matrix.width();
		 if((len <= 0) || (wid <= 0) || (len != wid)){
			// System.out.println("\n矩阵求逆（线性变换法） The matrix is not legal");
			 return null;
		 }
		 //构造A|E矩阵
		 Matrix matrixA = new Matrix(len,wid*2);
		 for (int i=1; i<=len; i++)
			 for (int j=1; j<=wid; j++){
			 matrixA.setElement(matrix.getElement(i,j),i,j);
		 }
		 
		 for (int i=1; i<=len; i++)
			 for (int j=wid+1; j<=wid*2; j++){
			 if (i==j-wid){
				 matrixA.setElement(1,i,j);
			 }
			 else 
				 matrixA.setElement(0,i,j);
		 }
		 //开始对A|E矩阵作线性变换
		 for (int i=1; i<=len; i++){
			 double max = matrixA.getElement(i,i);
			 double absmax = Math.abs(max);
			 
			 int maxrow = i;
			 for (int j=i; j<=len; j++){
				 double max2 = matrixA.getElement(j,i);
				 double absmax2 = Math.abs(max2);
				 if (absmax2>absmax){
					 maxrow = j;
					 max = max2;
					 absmax = absmax2;
				 }
			 }
			 //System.out.println(max);
			 if (absmax==0){
				// System.out.println("\n矩阵不满秩");
				 return null;
			 }
			 matrixA.chgRow(i,maxrow);
			 //return matrixA;
			 //对第i行作归一化处理
			 for (int k=1; k<=wid*2; k++){
				 double temp = matrixA.getElement(i,k) / max;
				 matrixA.setElement(temp,i,k);
			 }
			 //return matrixA;
			 //for(int x=1; x<=len; x++){
				 //for(int y=1; y<=wid*2; y++){
					 //System.out.print(matrixA.getElement(x,y));
					 //System.out.print(" ");
				 //}
				 //System.out.println("");
			 //}
			 //对其他行进行处理
			 //对上三角阵进行处理
			 for (int m=1; m<i; m++){
				 double para = matrixA.getElement(m,i);
				 if (para!=0){
					 for (int n=1; n<=wid*2; n++){
						 double num = matrixA.getElement(m,n);
						 num = num - matrixA.getElement(i,n) * para;
						 matrixA.setElement(num,m,n);
					 }
				 }
			 }

			 //对下三角阵进行处理
			 for (int m=i+1; m<=len; m++){
				 double para = matrixA.getElement(m,i);
				 if (para!=0){
					 for (int n=1; n<=wid*2; n++){
						 double num = matrixA.getElement(m,n);
						 num = num - matrixA.getElement(i,n) * para;
						 matrixA.setElement(num,m,n);
					 }
				 }
			 }
			 //return matrixA;
		 }
		 /*
		 * 返回结果E|B矩阵
		 * */
		 Matrix matrixB = new Matrix(len, wid);
		 for (int i = 1; i <= len; i++)
			 for (int j = wid+1; j <= wid*2; j++) {
				 double temp = matrixA.getElement(i,j);
				 matrixB.setElement(temp,i,j-wid);
			 }
		 return matrixB;
	 }	
}