/**
 * Basic Algorithms, V22.0310.003, Fall 1999 (Yap)
 *
 * This Matrix Class illustrates the use of 2-dimensional arrays
 *
 *	Constructors:
 *	  Matrix(n): gives an uninitialized nxn matrix 
 *	  Matrix(n,seed): gives a random nxn matrix of doubles in [0,1]
 *	  Matrix(n,flag): gives zero (flag=false) or identity nxn matrix 
 *
 * 	Public Methods:
 *	  static boolean equal(M,N): 	matrix equality
 *	  static Matrix  add(M,N): 	matrix addition
 *	  static Matrix  mul(M,N):	matrix multiplication
 *	  public void    dump():     	prints out THIS matrix 
 *	  public void    main(String):   main 
 */

import java.util.*;
// import java.lang.Math.*; // alternative source of randomness

public class Matrix
{
 private int size;	// Assert: n>0
 private double[][] entry;
    // Initialize random number generator:
 private String name;
 private static Random R = new Random((long)12345);

 //**********************************************************
 //********** constructors **********************************
 //**********************************************************

 // un-initialized matrix
 public Matrix(int n)
 { int i; int j;
   size = n;		
   entry = new double [n][n];	// uninitialized
 } // Matrix(n)

 // identity or zero matrix: flag=true => identity
 public Matrix(int n, boolean flag)
 { int i; int j;
   size = n;
   entry = new double [n][n];
   for (i = 0; i<n; i++)
   { for (j = 0; j<n; j++) 
         entry[i][j] = 0;
     if (flag) entry[i][i] = 1;
   }
 } // Matrix(n,boolean)

 // random matrix
 public Matrix(int n, int seed)
 { int i; int j;
   size = n;
   // seed is not used right now...
   entry = new double [n][n];
   for (i = 0; i<n; i++)
     for (j = 0; j<n; j++) 
       {
   //    entry[i][j] = Math.random();
         entry[i][j] = R.nextDouble();
       }
 } // Matrix(n,seed)
 
 //**********************************************************
 //********** methods ***************************************
 //**********************************************************

 // dump: prints out matrix
 public void dump()
 { int i; int j;
   System.out.println("size = " + size );
   for (i = 0; i<size; i++)
   {
     for (j = 0; j < size; j++)
        System.out.print( entry[i][j] + "\t");
     System.out.println("");
   }
 } // dump()

 // dump: prints out matrix with message
 public void dump(String m)
 { int i; int j;
   System.out.println(m); // print message
   this.dump();
 } // dump(String)


 // equal: matrix equality
 public static boolean equal(Matrix M1, Matrix M2)
 {
   // assert: M1.size = M2.size
   int i, j;
   for (i = 0; i < M1.size; i++)
     for (j = 0; j < M1.size; j++)
 	if (M1.entry[i][j] != M2.entry[i][j]) return false;
   return true;
 } //equal(M1,M2)

 // add: matrix addition
 public static Matrix add(Matrix M1, Matrix M2)
 {
   // assert: M1.size = M2.size
   int i, j;
   Matrix M = new Matrix(M1.size);

   for (i = 0; i < M1.size; i++)
     for (j = 0; j < M1.size; j++)
 	M.entry[i][j] = M1.entry[i][j] + M2.entry[i][j]; 
   return M;
 } //add(M1,M2)

// mul: matrix multiplication
 public static Matrix mul(Matrix M1, Matrix M2)
 {
   // assert: M1.size = M2.size
   int i, j, k;
   Matrix M = new Matrix(M1.size);

   for (i = 0; i < M1.size; i++)
     for (j = 0; j < M1.size; j++)
     {
 	M.entry[i][j] = M1.entry[i][0] * M2.entry[0][j]; 
	for (k = 1; k < M1.size; k++)
 	  M.entry[i][j] += M1.entry[i][k] * M2.entry[k][j]; 
     }
   return M;
 } //add(M1,M2)


 // main method
 public static void main(String[] args)
 {
   Matrix M = new Matrix(3, 0);    // random matrix
   Matrix N = new Matrix(3, true); // identity matrix
   Matrix P = new Matrix(3);	   // uninitialized matrix
   P = Matrix.mul(M,N); // note syntax...

   M.dump("*********************** M =");
   N.dump("*********************** N =");
   P.dump("*********************** P =");

   if (Matrix.equal(P,M)) 
	System.out.println("M and P are equal (CORRECT!)");
   else
	System.out.println("M and P are not equal (INCORRECT!)");
 } // main

}