//Matrices.java

import javax.swing.*;
import java.awt.*;
import java.text.*;
import java.util.*;

public class Matrices extends JApplet {
    public  void init () {

	JTextArea textarea = new JTextArea(22,100);
	textarea.setLineWrap( true );
	textarea.setFont( new Font("Courier",Font.BOLD,14) );
	JScrollPane scrollpane = new JScrollPane(textarea);
    	DecimalFormat d4 = new DecimalFormat ("0.0000");

	String input;
	StringTokenizer st;
	int Arows, Acols, Brows, Bcols;
        int r=0, c=0;
	double sum, detA, detB;
    	double [][] adjA;
    	double [][] adjB;
    	double [][] invA;
    	double [][] invB;
	
	input = JOptionPane.showInputDialog("Enter A matrix's #rows and #cols");//,
        st = new StringTokenizer(input);
        Arows = Integer.parseInt(st.nextToken());
        Acols = Integer.parseInt(st.nextToken());
        double [][] A = new double[Arows][Acols];
	input = JOptionPane.showInputDialog("Enter/paste A matrix's components separated by spaces in row major order");//,
        st = new StringTokenizer(input);
 	r = c = 0;
        while (st.hasMoreTokens()) {
            A[r][c++] = Double.parseDouble(st.nextToken());
            if (c == Acols) {
            	c = 0;
            	r++;
            }
        }
	
	input = JOptionPane.showInputDialog("Enter B matrix's #rows and #cols");//,
        st = new StringTokenizer(input);
        Brows = Integer.parseInt(st.nextToken());
        Bcols = Integer.parseInt(st.nextToken());
        double [][] B = new double[Brows][Bcols];	
        input = JOptionPane.showInputDialog("Enter/paste B matrix's components separated by spaces in row major order");//,
        st = new StringTokenizer(input);
 	r = c = 0;
        while (st.hasMoreTokens()) {
            B[r][c++] = Double.parseDouble(st.nextToken());
            if (c == Bcols) {
            	c = 0;
            	r++;
            }
        }

	textarea.append("A:\n");
	display (A, Arows, Acols, textarea);
	textarea.append("\nAt:\n");
	display (transpose(A,Arows), Arows, Acols, textarea);
	if (Arows == Acols) {    //square
	    detA = det(A,Arows);	    
	    textarea.append("\ndet A="+detA);
	    if (detA != 0) {
	    	adjA = adjoint(A,Arows);
	    	textarea.append("\nadj A:\n");
	        display (adjA, Arows, Acols, textarea);
	        
	        invA = inverse(adjA,Arows,detA);
	    	textarea.append("\ninv A:\n");
	        display (invA, Arows, Acols, textarea);
	    }
	}   
	    

	textarea.append("\nB:\n");
	display (B, Brows, Bcols, textarea);
	textarea.append("\nBt:\n");
	display (transpose(B,Brows), Brows, Bcols, textarea);
	if (Brows == Bcols) {    //square
	    detB = det(B,Brows);	    
	    textarea.append("\ndet B="+detB);
	    if (detB != 0) {
	    	adjB = adjoint(B,Brows);
	    	textarea.append("\nadj B:\n");
	        display (adjB, Brows, Bcols, textarea);
	        
	        invB = inverse(adjB,Brows,detB);
	    	textarea.append("\ninv B:\n");
	        display (invB, Brows, Bcols, textarea);
	    }
	}   	    
	    

	if (Acols == Brows) {
	    textarea.append("\nAB:\n");
	    double [][] AB = new double[Arows][Bcols];	    
	    for (int i=0; i<Arows; i++)
	        for (int j=0; j<Bcols; j++) {
	            sum = 0;
	            for (int k=0; k<Brows; k++)	
	                sum += A[i][k] * B[k][j];
	            AB[i][j] = sum;
	        }
	    display (AB, Arows, Bcols, textarea);

	}
	else
	     textarea.append("\nAB undefined\n");	     	

	if (Bcols == Arows) {
	    textarea.append("\nBA:\n");
	    double [][] BA = new double[Brows][Acols];	    
	    for (int i=0; i<Brows; i++)
	        for (int j=0; j<Acols; j++) {
	            sum = 0;
	            for (int k=0; k<Arows; k++)	
	                sum += B[i][k] * A[k][j];
	            BA[i][j] = sum;
	        }
	    display (BA, Brows, Acols, textarea);

	}
	else
	     textarea.append("\nBA undefined\n");	     	

	if (Arows==Brows && Acols==Bcols) {
	    textarea.append("\nA+B:\n");
	    double [][] AplusB = new double[Brows][Bcols];
	    for (int i=0; i<Brows; i++) {
	        for (int j=0; j<Bcols; j++)
	            AplusB[i][j] = A[i][j] + B[i][j];
	    }
	    display (AplusB, Arows, Acols, textarea);

	}
	else
	     textarea.append("\nA+B undefined\n");
	     
		    
/*	if (Arows == Acols) {    //square
	    textarea.append("\nA minor01:\n");
	    display (minorMij(A,Arows,0,1), Arows-1, Acols-1, textarea); 	    
	    textarea.append("\nA minor00:\n");
	    display (minorMij(A,Arows,0,0), Arows-1, Acols-1, textarea); 
	    textarea.append("\nA minor33:\n");
	    display (minorMij(A,Arows,3,3), Arows-1, Acols-1, textarea); 
	}
*/	

	JOptionPane.showMessageDialog(null, 
				      scrollpane,
				      "Matrices",
				      JOptionPane.PLAIN_MESSAGE);
    }
    
    

    
    void display (double M[][], int rows, int cols, JTextArea textarea) {
    	for (int i=0; i<rows; i++) {
	    for (int j=0; j<cols; j++)
	    	textarea.append(""+M[i][j]+"  ");	
	    textarea.append("\n");
    	}
    }
    
    double det (double [][] M, int n) {
    	double sum=0;
    	
    	if (n == 2)
    	    return M[0][0]*M[1][1] - M[0][1]*M[1][0];
    	else {
    	    for (int j=0; j<n; j++)
    	    	sum += M[0][j] * Math.pow(-1,2+j) * det(minorMij(M,n,0,j),n-1);
    	    return sum;    
    	}
    }
    
    //return submatrix less row i and column j
    double [][] minorMij (double [][]M, int n, int i, int j) {
    	double [][] minorIJ = new double [n-1][n-1];
    	int newrow=0, newcol=0;
    	
    	for (int oldrow=0; oldrow<n; oldrow++) {
    	    if (oldrow != i) {
    	        for (int oldcol=0; oldcol<n; oldcol++)
    	    	    if (oldcol != j)
    	    	        minorIJ[newrow][newcol++] = M[oldrow][oldcol];
		newrow++;
		newcol = 0;    	
    	    }
    	}
    	return minorIJ;
    }
    
    double [][] adjoint (double [][]M, int n) {
    	double [][] adj = new double [n][n];
    	
     	for (int i=0; i<n; i++)
     	    for (int j=0; j<n; j++)  
     	    	if (n > 2) 	
    	            adj[i][j] = Math.pow(-1,i+j+2) * det(minorMij(M,n,i,j),n-1);
    	        //else
    	          //  adj[i][j] = Math.pow(-1,i+j+2) * det(M,n);
    	
    	if (n == 2) {   // a b c d  -> d -c -b a
    	    adj[0][0] = M[1][1];
    	    adj[0][1] = -M[1][0];
    	    adj[1][0] = -M[0][1];
    	    adj[1][1] = M[0][0];
    	} 
    	return transpose(adj,n);
    }
    
    //given adjoint matrix and determinant, return inverse
    double [][] inverse (double [][]adj, int n, double det) {
    	double [][] inv = new double [n][n];
    	
     	for (int i=0; i<n; i++)
     	    for (int j=0; j<n; j++)   	
    	        inv[i][j] = 1/det * adj[i][j];
    	        	
    	return inv;
    }   
    	
    double [][] transpose (double M[][], int n) {
    	double [][] t = new double [n][n];

    	for (int i=0; i<n; i++)
    	    for (int j=0; j<n; j++)
    	    	t[i][j] = M[j][i];
    	    	
        return t;
    }    	
}
/*
 1 -1 1 -1 1 1 2 9 5 -1 7 15


-4 6 2 1 1 0 -1 0 3 -2 2 0 4 -5 6 3


3 0 2 -1 1 -3 5 2 1

3 -1 2 2 -1 1 -2 3 3
3 1 2 4 2 0 1 0 -1 2 -4 0 3 2 1 1 

1 3 2 -4 3 0 2 1 -7 0 1 5 6 -6 10 2
2 0 1 5 1 2 3 4 3 4 -2 1 1 7 -3 2

2 -1 1 -1 3 4 -2 1 0

3 4 -5 -1 -2 2 0 1 0

4 1 3 0 2 0 1 0 1
1 -3 0 0 0 3 -1 4 -1

*/