// Utilities.java
import java.util.Vector;

public class Utilities
{
   private static int[][] m, s;
   private static int[] seq;
   private static int scalarMults = 0;
   private static boolean errorPresent;

   public static Matrix multiply_left_right(Vector v) throws MatrixException
   {
      Matrix curr = (Matrix)v.elementAt(0);
      int pos = 1;
      while ((!errorPresent) && (pos < v.size()))
      {
         try
         {
            curr = matrix_multiply(curr, (Matrix)v.elementAt(pos));
         }
         catch(MatrixException me)
         {
            errorPresent = true;
         }
         pos++;
      }
      return curr;
   }

   private static Matrix chain_multiply(Vector v, int i, int j) throws MatrixException
   {
      if (!errorPresent)
      {
         if (j > i)
         {
             Matrix m = null;
             try
             {
                Matrix x = chain_multiply(v, i, s[i][j]);
                Matrix y = chain_multiply(v, s[i][j] + 1, j);
                m = matrix_multiply(x, y);
             }
             catch(MatrixException me)
             {
                errorPresent = true;
             }
             return m;
         }
         else
            return (Matrix)v.elementAt(i);
      }
      else
         throw new MatrixException("Incompatible matrix dimensions.");
   }

   public static int getScalarMults()
   {
      return scalarMults;
   }

   public static void initScalarMults()
   {
      scalarMults = 0;
   }

   public static Matrix matrix_multiply(Matrix A, Matrix B) throws MatrixException
   {
      if (A.getCols() != B.getRows())
         throw new MatrixException("Incompatible matrix dimensions.");
      else
      {
         int rows = A.getRows(),
             cols = B.getCols();
         int[][] C = new int[rows][cols];
         for(int i = 0; i < rows; i++)
            for(int j = 0; j < cols; j++)
            {
               C[i][j] = 0;
               for(int k = 0; k < A.getCols(); k++)
               {
                  C[i][j] = C[i][j] + A.getArray()[i][k] * B.getArray()[k][j];
                  scalarMults++;
               }
            }
         Matrix m = new Matrix(-1, rows, cols, C);
         return m;
      }
   }

   public static void matrix_chain_order(int[] p)
   {
      int vectorLength = p.length;
      int n = vectorLength - 1;
      m = new int[vectorLength + 1][vectorLength + 1];
      s = new int[vectorLength + 1][vectorLength + 1];
      for(int L = 2; L <= n; L++)
         for(int i = 1; i <= n - L + 1; i++)
         {
            int j = i + L - 1;
            m[i][j] = Integer.MAX_VALUE;
            for(int k = i; k <= j - 1; k++)
            {
               int q = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
               if (q < m[i][j])
               {
                  m[i][j] = q;
                  s[i][j] = k;
               }
            }
         }
   }

   public static Matrix matrix_chain_multiply(Vector v) throws MatrixException
   {
      errorPresent = false;
      try
      {
         return chain_multiply(v, 0, v.size() - 1);
      }
      catch(MatrixException me)
      {
         throw new MatrixException(me.getMsg());
      }
   }

   public static int[] matrix_sequence(Vector v) throws MatrixException
   {
      seq = new int[v.size() + 1];
      for(int i = 0; i < v.size() - 1; i++)
      {
         Matrix m1 = (Matrix)v.elementAt(i),
                m2 = (Matrix)v.elementAt(i + 1);
         if (m1.getCols() == m2.getRows())
            seq[i] = m1.getRows();
         else
            throw new MatrixException("Matrices " + (m1.getSequenceNumber() + 1) +
                      " and " + (m2.getSequenceNumber() + 1) + " cannot be multiplied.");
      }
      Matrix m = (Matrix)v.elementAt(v.size() - 1);
      seq[v.size() - 1] = m.getRows();
      seq[v.size()] = m.getCols();
      return seq;
   }

   public static int[][] getTableM()
   {
      return m;
   }

   public static int[][] getTableS()
   {
      return s;
   }

   public static String seqToString()
   {
      StringBuffer sb = new StringBuffer("<");
      for(int i = 0; i < seq.length; i++)
      {
         sb.append(seq[i]);
         if (i == seq.length - 1)
            sb.append(">");
         else
            sb.append(",");
      }
      return sb.toString();
   }

   public static void displayTable(int[][] table)
   {
      for(int c = table[0].length - 2; c > 0; c--)
      {
         for(int r = 1; r <= c; r++)
            System.out.print(m[r][c] + "\t");
         System.out.println("");
      }
   }

   public static String removeSpaces(String input)
   {
      CharArray cArray = new CharArray(input);
      int pos = 0;
      while (pos < cArray.length)
      {
         if (cArray.charAt(pos) == ' ')
            cArray.delete(pos, 1);
         else
            pos++;
      }
      return cArray.toString();
   }

}