-MatrixOperationException.java-----------------------------------------------------

public class MatrixOperationException extends Exception{
	public MatrixOperationException(String arg0){
		super(arg0);
	}
}


-Matrix.java-----------------------------------------------------------------------

public class Matrix{
	private double[][] values;
	private int xDim, yDim;
	
	public static Matrix identity(int size){
		Matrix result = new Matrix(size, size);
		for(int n=0;n<size;n++){
			try{
				result.setCell(n,n,1);
			}catch (MatrixOperationException e){}
		}
		return result;
	}
	
	public static Matrix add(Matrix A, double B) throws MatrixOperationException{
		Matrix result=new Matrix(A.getHeight(),A.getWidth());
		for(int i=0;i<A.getHeight();i++){
			for(int j=0;j<A.getWidth();j++){
				result.setCell(i,j,A.value(i,j)+B);
			}
		}
		return result;
	}
	
	public static Matrix add(Matrix A, Matrix B) throws MatrixOperationException{
		if(A.getWidth()!=B.getWidth() || A.getHeight()!=B.getHeight()){
			throw new MatrixOperationException("Problem with addition. Matrix sizes incompatible");
		}else{
			Matrix result=new Matrix(A.getWidth(),A.getHeight());
			for(int i=0;i<A.getHeight();i++){
				for(int j=0;j<A.getWidth();j++){
					result.setCell(i,j,A.value(i,j)+B.value(i,j));
				}
			}
			return result;
		}
	}
	
	public static Matrix multiply(Matrix A, double other) throws MatrixOperationException{
		Matrix result = new Matrix(A.getHeight(),A.getWidth());
		for(int i=0;i<A.getHeight();i++){
			for(int j=0;j<A.getWidth();j++){
				result.setCell(i,j,A.value(i,j)*other);
			}
		}
		return result;
	}
	
	public static Matrix multiply(Matrix A, Matrix B) throws MatrixOperationException{
		if(A.getWidth()!=B.getHeight()){
			throw new MatrixOperationException("Matrix sizes incompatible");
		}else{
			Matrix result=new Matrix(A.getHeight(),B.getWidth());
			double newval;
			for(int i=0;i<result.getHeight();i++){
				for(int j=0;j<result.getWidth();j++){
					newval=0;
					for(int n=0;n<A.getWidth();n++){
						newval+=A.value(i,n)*B.value(n,j);
					}
					result.setCell(i,j,newval);
				}
			}
			return result;
		}
	}
	
	private static String round(double number){
		int rounded = (int) (number*100);
		number = rounded;
		number /= 100;
		return String.valueOf(number);
	}
	
	public static String format(Matrix subject){
		String result="";
		String current;
		for(int i=0;i<subject.getHeight()-1;i++){
			for(int j=0;j<subject.getWidth()-1;j++){
				result += round(subject.value(i,j))+" ";
			}
			result += round(subject.value(i,subject.getWidth()-1)) + "\n";
		}
		for(int j=0;j<subject.getWidth()-1;j++){
			result += round(subject.value(subject.getHeight()-1,j))+" ";
		}
		result += round(subject.value(subject.getHeight()-1,subject.getWidth()-1));
		return result;
	}
	
	public static Matrix parse(String text) throws MatrixOperationException{
		int numrows = 1, numcolumns[], numcols = 1;
		for(int i=0;i<text.length();i++){
			if(Character.getType(text.charAt(i)) == 15){
				numrows++;
			}
		}
		numcolumns = new int[numrows];
		for(int i=0;i<numrows;i++){
			numcolumns[i]=1;
		}
		int n=0;
		for(int i=0;i<text.length();i++){
			if(Character.getType(text.charAt(i)) == 15){
				numcols=Math.max(numcolumns[n], numcols);
				n++;
			}
			if(text.charAt(i) == ' '){
				numcolumns[n]++;
			}
		}
		numcols=Math.max(numcolumns[n], numcols);
		n = 0;
		Matrix result = new Matrix(numrows, numcols);
		for(int i=0;i<numrows;i++){
			for(int j=0;j<numcolumns[i];j++){
				String current = "";
				while(n < text.length() && !(text.charAt(n) == ' ' || Character.getType(text.charAt(n)) == 15)){
					current += text.charAt(n);
					n++;
				}
				n++;
				if(current == ""){
					current = "0";
				}
				try{
					result.setCell(i,j,Double.parseDouble(current));
				}catch (MatrixOperationException e){
					throw new MatrixOperationException("Error in parsing. Check formatting.");
				}
			}
		}
		return result;
	}
	
	public static Matrix minor(Matrix subject, int y, int x) throws MatrixOperationException{
		if(y>=subject.getHeight() || x>=subject.getWidth()){
			throw new MatrixOperationException("(" + y + "," + x + ")th minor is invalid.");
		}else{
			Matrix result = new Matrix(subject.getHeight()-1, subject.getWidth()-1);
			for(int i=0;i<result.getHeight();i++){
				for(int j=0;j<result.getWidth();j++){
					if(i<y && j<x){
						result.setCell(i,j,subject.value(i,j));
					}
					if(i<y && j>=x){
						result.setCell(i,j,subject.value(i,j+1));
					}
					if(i>=y && j<x){
						result.setCell(i,j,subject.value(i+1,j));
					}
					if(i>=y && j>=x){
						result.setCell(i,j,subject.value(i+1,j+1));
					}
				}
			}
			return result;
		}
	}
	
	public static Matrix flip(Matrix subject) throws MatrixOperationException{
		Matrix result = new Matrix(subject.getHeight(),subject.getWidth());
		for(int i=0;i<result.getHeight();i++){
			for(int j=0;j<result.getWidth();j++){
				result.setCell(i,j,subject.value(i, subject.getWidth()-(j+1)));
			}
		}
		return result;
	}
	
	public static double determinant(Matrix subject) throws MatrixOperationException{
		if(subject.getHeight()!=subject.getWidth()){
			throw new MatrixOperationException("Determinant only valid for square matrices");
		}else{
			if(subject.getHeight()==2){
				return subject.value(0,0)*subject.value(1,1)
					  -subject.value(0,1)*subject.value(1,0);
			}else{
				double result = 0;
				for(int j=0;j<subject.getWidth();j++){
					result+= Math.pow(-1,2+j)
							*subject.value(0,j)
							*determinant(minor(subject, 0, j));
				}
				return result;
			}
		}
	}
	
	public static Matrix inverse(Matrix subject) throws MatrixOperationException{

		if(subject.getHeight()!=subject.getWidth() || subject.getHeight()==1 || determinant(subject)==0){
			throw new MatrixOperationException("Matrix has no inverse");
		}else{
			double determinant = determinant(subject);
			int order = subject.getHeight();
			if(order>3){
				throw new MatrixOperationException("Matrix is too large for current inverse algorithm.");
			}else{
				Matrix result = new Matrix(order, order);
				if(subject.getHeight()==2){
					result.setCell(0,0, subject.value(1,1));
					result.setCell(0,1,-subject.value(0,1));
					result.setCell(1,0,-subject.value(1,0));
					result.setCell(1,1, subject.value(0,0));
				}else{
					Matrix currentMinor;
					for(int i=0;i<3;i++){
						for(int j=0;j<3;j++){
							currentMinor=minor(subject,j,i);
							if((i+j)%2!=0){
								currentMinor=flip(currentMinor);
							}
							result.setCell(i,j,determinant(currentMinor));
						}
					}
				}
				result = multiply(result, 1/determinant);
				return result;
			}
		}
	}
	
	public static boolean areEqual(Matrix A, Matrix B){
		boolean result = true;
		if(A.getHeight()!=B.getHeight() || A.getWidth()!=B.getWidth()){
			result=false;
		}else{
			for(int i=0;i<A.getHeight();i++){
				for(int j=0;j<A.getWidth();j++){
					if(A.value(i,j)!=B.value(i,j)){
						result=false;
					}
				}
			}
		}
		return result;
	}

	public Matrix(int height, int width){
		xDim = width;
		yDim = height;
		values = new double[yDim][xDim];
		for(int i=0;i<yDim;i++){
			for(int j=0;j<xDim;j++){
				values[i][j]=0;
			}
		}
	}

	public Matrix(int height, int width, Matrix other) throws MatrixOperationException{
		xDim = width;
		yDim = height;
		values = new double[yDim][xDim];
		if(other.getWidth()>xDim || other.getHeight()>yDim){
			throw new MatrixOperationException("Matrix sizes incompatible");
		}else{
			for(int i=0;i<other.getHeight();i++){
				for(int j=0;j<other.getWidth();j++){
					values[i][j]=other.value(i,j);
				}
			}
		}			
	}

	public int getWidth(){
		return xDim;
	}
	
	public int getHeight(){
		return yDim;
	}
	
	public double value(int yRef, int xRef){
		return values[yRef][xRef];
	}
	
	public void setCell(int yRef, int xRef, double newval) throws MatrixOperationException{
		if(xRef>xDim || yRef>yDim){
			throw new MatrixOperationException("Out of matrix dimensions");
		}else{
			values[yRef][xRef]=newval;
		}
	}
}


-MatrixControls.java--------------------------------------------------------------------

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

public class MatrixControls extends Applet implements ActionListener{
	private JPanel mainPanel, appPanel,
				   unaryA, unaryB, subC,
				   matrixA, matrixB, matrixC,
				   centerPanel;
	private JComboBox opCombo;
	private JButton detAButton, invAButton,
					detBButton, invBButton,
					computeButton;
	private JTextArea displayA, displayB, displayC;
	private JLabel equals, opIcon, errorDisplay;
	
	
	public void init(){
		setSize(850,200);
		
		detAButton = new JButton("Determinant");
		invAButton = new JButton("Inverse");
		detAButton.addActionListener(this);
		invAButton.addActionListener(this);
		
		detBButton = new JButton("Determinant");
		invBButton = new JButton("Inverse");
		detBButton.addActionListener(this);
		invBButton.addActionListener(this);
		
		computeButton = new JButton("Compute");
		computeButton.addActionListener(this);
		
		String[] operations = {"Add", "Subtract", "Multiply", "Divide"};
		opCombo = new JComboBox(operations);
		opCombo.addActionListener(this);
		
		Font stdFont = new Font("Monospaced", Font.PLAIN, 16);
		opIcon = new JLabel("+");
		equals = new JLabel("=");
		errorDisplay = new JLabel(" ");
		opIcon.setFont(stdFont);
		equals.setFont(stdFont);
		
		displayA = new JTextArea(6, 24);
		displayB = new JTextArea(6, 24);
		displayC = new JTextArea(6, 24);
		displayC.setEditable(false);
		
		unaryA = new JPanel(new BorderLayout(5,5));
		unaryA.add(detAButton, BorderLayout.NORTH);
		unaryA.add(invAButton, BorderLayout.SOUTH);
		
		unaryB = new JPanel(new BorderLayout(5,5));
		unaryB.add(detBButton, BorderLayout.NORTH);
		unaryB.add(invBButton, BorderLayout.SOUTH);
		
		subC = new JPanel(new BorderLayout(5,5));
		subC.add(opCombo, BorderLayout.NORTH);
		subC.add(computeButton, BorderLayout.SOUTH);
		
		matrixA = new JPanel(new BorderLayout(5,5));
		matrixA.add(displayA, BorderLayout.CENTER);
		matrixA.add(unaryA, BorderLayout.SOUTH);
		
		matrixB = new JPanel(new BorderLayout(5,5));
		matrixB.add(displayB, BorderLayout.CENTER);
		matrixB.add(unaryB, BorderLayout.SOUTH);
		
		matrixC = new JPanel(new BorderLayout(5,5));
		matrixC.add(displayC, BorderLayout.CENTER);
		matrixC.add(subC, BorderLayout.SOUTH);
		
		centerPanel = new JPanel(new BorderLayout(5,5));
		centerPanel.add(opIcon, BorderLayout.WEST);
		centerPanel.add(matrixB, BorderLayout.CENTER);
		centerPanel.add(equals, BorderLayout.EAST);
		
		mainPanel = new JPanel(new BorderLayout(5,5));
		mainPanel.add(matrixA, BorderLayout.WEST);
		mainPanel.add(centerPanel, BorderLayout.CENTER);
		mainPanel.add(matrixC, BorderLayout.EAST);
		mainPanel.add(errorDisplay, BorderLayout.SOUTH);
		
		appPanel = new JPanel(new BorderLayout(5,5));
		appPanel.add(mainPanel, BorderLayout.CENTER);
		appPanel.add(Box.createRigidArea(new Dimension(5,0)),BorderLayout.WEST);
		appPanel.add(Box.createRigidArea(new Dimension(5,0)),BorderLayout.EAST);
		appPanel.add(Box.createRigidArea(new Dimension(0,5)),BorderLayout.NORTH);
		appPanel.add(Box.createRigidArea(new Dimension(0,5)),BorderLayout.SOUTH);
		
		add(appPanel);
	}

	public void actionPerformed(ActionEvent event){
		Object source = event.getSource();
		
		if(source == opCombo){
			if(opCombo.getSelectedIndex() == 0){
				opIcon.setText("+");
			}
			if(opCombo.getSelectedIndex() == 1){
				opIcon.setText("-");
			}
			if(opCombo.getSelectedIndex() == 2){
				opIcon.setText("x");
			}
			if(opCombo.getSelectedIndex() == 3){
				opIcon.setText("/");
			}
		}
		
		if(source == invAButton){
			try{
				displayC.setText(Matrix.format(
								 Matrix.inverse(
								 Matrix.parse(
								 displayA.getText()))));
				errorDisplay.setText(" ");
			}catch(MatrixOperationException e){
				errorDisplay.setText(e.getMessage());
			}
		}
		if(source == invBButton){
			try{
				displayC.setText(Matrix.format(
								 Matrix.inverse(
								 Matrix.parse(
								 displayB.getText()))));
				errorDisplay.setText(" ");
			}catch(MatrixOperationException e){
				errorDisplay.setText(e.getMessage());
			}
		}
		
		if(source == detAButton){
			try{
				displayC.setText(Double.toString(
								 Matrix.determinant(
								 Matrix.parse(
								 displayA.getText()))));
				errorDisplay.setText(" ");
			}catch(MatrixOperationException e){
				errorDisplay.setText(e.getMessage());
			}
		}
		if(source == detBButton){
			try{
				displayC.setText(Double.toString(
								 Matrix.determinant(
								 Matrix.parse(
								 displayB.getText()))));
				errorDisplay.setText(" ");
			}catch(MatrixOperationException e){
				errorDisplay.setText(e.getMessage());
			}
		}
		
		if(source == computeButton){
			try{
				Matrix A = Matrix.parse(displayA.getText());
				Matrix B = Matrix.parse(displayB.getText());
				boolean Adouble = (A.getHeight()==1 && A.getWidth()==1);
				boolean Bdouble = (B.getHeight()==1 && B.getWidth()==1);

				if(opCombo.getSelectedIndex() == 0){
					if(Adouble && Bdouble){
						displayC.setText(String.valueOf(
										 Double.parseDouble(displayA.getText())
										+Double.parseDouble(displayB.getText())));
					}
					if(Adouble && !Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.add(B,
										 Double.parseDouble(displayA.getText()))));
					}
					if(!Adouble && Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.add(A, 
										 Double.parseDouble(displayB.getText()))));
					}
					if(!Adouble && !Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.add(A, B)));
					}
				}
				if(opCombo.getSelectedIndex() == 1){
					if(Adouble && Bdouble){
						displayC.setText(String.valueOf(
										 Double.parseDouble(displayA.getText())
										-Double.parseDouble(displayB.getText())));
					}
					if(Adouble && !Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.add(Matrix.multiply(B, -1),
										 Double.parseDouble(displayA.getText()))));
					}
					if(!Adouble && Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.add(A, 
										 Double.parseDouble(displayB.getText())* -1)));
					}
					if(!Adouble && !Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.add(A, Matrix.multiply(B, -1))));
					}
				}
				if(opCombo.getSelectedIndex() == 2){
					if(Adouble && Bdouble){
						displayC.setText(String.valueOf(
										 Double.parseDouble(displayA.getText())
										*Double.parseDouble(displayB.getText())));
					}
					if(Adouble && !Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.multiply(B,
										 Double.parseDouble(displayA.getText()))));
					}
					if(!Adouble && Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.multiply(A,
										 Double.parseDouble(displayB.getText()))));
					}
					if(!Adouble && !Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.multiply(A, B)));
					}
				}
				if(opCombo.getSelectedIndex() == 3){
					if(Adouble && Bdouble){
						displayC.setText(String.valueOf(
										 Double.parseDouble(displayA.getText())
										/Double.parseDouble(displayB.getText())));
					}
					if(Adouble && !Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.multiply(Matrix.inverse(B),
										 Double.parseDouble(displayA.getText()))));
					}
					if(!Adouble && Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.multiply(A,
										 1/Double.parseDouble(displayB.getText()))));
					}
					if(!Adouble && !Bdouble){
						displayC.setText(Matrix.format(
										 Matrix.multiply(A,Matrix.inverse(B))));
					}
				}
				errorDisplay.setText(" ");
			}catch(Exception e){
				errorDisplay.setText(e.getMessage());
			}
		}
	}
}