Matrix Inversion (JAVA) Elementary Row Transform

package gaodai.matrix;

import gaodai.determinant.DeterminantCalculation;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * Matrix inversion (elementary row transformation)
 * @author Qiu Wanchi
 *
 */
public class InverseOfMatrix {
	
	private List<List<Double>> matrix;
	private int lineNum;
	private int columnNum;
	
	public InverseOfMatrix(List<List<Double>> data){
		matrix = data;
		lineNum = data.size();
		columnNum = data.get(0).size();
	}
	
	public void caculate() throws Exception{
		
		//1. Non-square cannot be reversed
		//2. Founder's determinant value is zero and cannot be inverted
		if( lineNum != columnNum){
			throw new Exception("This matrix cannot be inverse>>>>>>>>>>>>>>>>>>");
		}
		List<List<Double>> tempList = new ArrayList<List<Double>>();
		for(List<Double> l : matrix){
			List<Double> newList = new ArrayList<Double>();
			newList.addAll(l);
			tempList.add(newList);
		}
		
		DeterminantCalculation d = new DeterminantCalculation(tempList);
		d.chang2UpperTriangle();
		double result = d.getValue();
		if(result == 0){
			throw new Exception("This matrix cannot be inverse>>>>>>>>>>>>>>>>>>");
		}
		
		//Increase the identity matrix
		for(int i = 0; i < lineNum; i++){
			List<Double> list = matrix.get(i);
			for(int j = 0; j < columnNum; j++){
				if(i == j){
					list.add(1.0);
				}else{
					list.add(0.0);
				}
			}
		}
		print();
		chang2UpperTriangle();//Turn into upper triangle
		changeReducedMatrix();//Reduced matrix
		print();
	}
	
	public void getValue(){
		boolean flag = true;
		for(int i = 0; i < lineNum; i++){
			if(matrix.get(i).get(i) == 0){
				flag = false;
			}
			if(!flag){
				break;
			}
		}
		
		if(!flag){
			System.out.println("This matrix is ​​irreversible>>>>>>>>>>>>>>");
		}else{
			
			for(int i = 0; i < lineNum; i++){
				List<Double> list = matrix.get(i);
				for(int j = 0; j < columnNum; j++){
					list.remove(0);
				}
			}
			System.out.println("逆矩阵为>>>>>>>>>>>>>>>>>");
			print();
		}
	}
	
	/**
	 * Print
	 */
	public void print() {
		int i = 0, j = 0;
		for (List<Double> line : matrix) {
			for (double element : line) {
				System.out.print(element);
				System.out.print("(" + i + "," + j + ")  ");
				System.out.print("  ");
				j++;
			}
			System.out.println();
			i++;
			j = 0;
		}
		System.out.println();
	}
	
	/**
	 * Check whether it is an upper triangle, if not, continue to calculate
	 *
	 * @return
	 */
	public boolean isCaculate() {
		boolean hasCaculate = false;
		for (int i = 0; i < matrix.size(); i++) {
			for (int j = 0; j < i; j++) {
				if (matrix.get(i).get(j) != 0.0) {
					System.out.println("(" + (i + 1) + "," + (j + 1) + ") element value is not zero");
					hasCaculate = true;
					break;
				}
			}
			if (hasCaculate) {
				break;
			}
		}
		return hasCaculate;
	}

	private int caculateTimes;

	/**
	 * into an upper triangle
	 * @throws Exception
	 */
	public void chang2UpperTriangle() throws Exception {

		if (!isCaculate()) {
			return;
		}
		
		int min = lineNum;
		caculateTimes++;
		System.out.println("-------------th" + caculateTimes + "time calculation-------------");
		for (int i = 0; i < min; i++) {
			for (int j = i + 1; j < min; j++) {
				double multiplyNum = -1 * matrix.get(j).get(i) / matrix.get(i).get(i);
				if (multiplyNum == 0) {
					continue;
				}
				this.lineMultiplyNumAdd2OtherLine(multiplyNum, (i + 1), (j + 1));
				print();
			}
		}
		print();
		chang2UpperTriangle();
	}
	
	/**
	 * becomes a reduced matrix
	 */
	public void changeReducedMatrix() throws Exception{
		for(int i = 0; i < lineNum; i++){//行
			if(i == 0){
				//continue;
			}
			List<Double> temp = matrix.get(i);
			
			for(Double d : temp){
				if(d == 0){
					continue;
				}
				double multiplyNum = 1.0 / d;
				
				for(int a = 0; a < temp.size(); a++){
					temp.set(a, temp.get(a) * multiplyNum);
				}
				break;
			}
			print();
			for(int j = 0; j <= columnNum; j++){//列
				
				if(temp.get(j) != 0){//This number is not zero, this number is the i-th row and the j-th column
					for(int t = 0; t < lineNum; t++){//行
						if(t == i || matrix.get(t).get(j) == 0){//Other lines in this column
							continue;
						}
						
						double multiplyNum = -1 * matrix.get(t).get(j) / temp.get(j);
						this.lineMultiplyNumAdd2OtherLine(multiplyNum, (i + 1), (t + 1));
						print();
					}
					break;
				}
			}
		}
	}
	
	/**
	 * Line a times number and add to line b
	 * @param number The number to multiply by
	 * @param a line number
	 * @param b line number
	 * @throws Exception
	 */
	public void lineMultiplyNumAdd2OtherLine(double number, int a, int b) throws Exception {
		if (a < 1 || a > matrix.size() || b < 1 || b > matrix.size()) {
			throw new Exception("The input line number is invalid");
		}
		List<Double> aLine = matrix.get(a - 1);
		List<Double> bLine = matrix.get(b - 1);

		for (int i = 0; i < bLine.size(); i++) {
			double temp = bLine.get(i) + aLine.get(i) * number;
			bLine.set (i, temp);
		}
		System.out.println("Line " + a + " multiplied by " + number + " and added to line " + b + " Line: ");
	}
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		System.out.println("Please enter the number of rows and columns of the matrix, separated by commas:");
		
		String sn = scanner.next();
		String[] snArr = sn.split(",");
		int lineNum = Integer.valueOf(snArr[0]);
		int columnNum = Integer.valueOf(snArr[1]);
		List<List<Double>> matrix = new ArrayList<List<Double>>();
		for(int i = 0; i < lineNum; i++){
			System.out.println("Please enter the number of lines " + (i + 1) + ", separated by commas: ");
			String lineData = scanner.next();
			String[] lineDataArr = lineData.split(",");
			List<Double> line = new ArrayList<Double>();
			matrix.add(line);
			for(int j = 0; j < columnNum; j++){
				line.add(Double.valueOf(lineDataArr[j]));
			}
		}
		
		InverseOfMatrix m = new InverseOfMatrix(matrix);
		m.print();
		try {
			m.caculate();
			m.getValue();
		} catch (Exception e) {
			e.printStackTrace ();
		}
	}
}