const int SIZE=6;

class matrix
{
   private:
      int col;
      int row;
      double e[SIZE][SIZE];

   public:
      // Constructors
      matrix (); // Sets every element to zero along with the dimensions
      matrix (int, int, double[SIZE][SIZE]); // initialize constructor
      matrix (const matrix&);

      // Member functions
      void input ();
      void output ();
      void identity(const int&); // creates an n x n identity matrix
      matrix s_mult(const double&); // Multiplies the calling object by "double"
      matrix add(const matrix&);
      matrix subtract(const matrix&);
      matrix multiply(const matrix&);
      matrix augment(const matrix&);
      matrix inverse ();
      void findpivot(matrix&, int);
      void rowdivide(const int&, double, matrix&);
      void copy (matrix&);
      void revcopy (matrix&);
      double det();
      matrix minor(int, int);

      // Overloaded Operators
};

// Constructors
// Default Constructor
matrix::matrix ()
{
   row = 0;
   col = 0;
   for (int j=0; j < SIZE; j++)
   {
      for (int i=0; i < SIZE; i++)
	 e[j][i]=0;
   }
} // end default constructor

// end initialize constructor
matrix::matrix (int a, int b, double x[SIZE][SIZE])
{
   row = a;
   col = b;
   for (int i=0, j = 0; j < b; i++)
   {
      e[j][i]=x[j][i];
      if (i/(a-1)==1)
      {
	 j++;
	 i=0;
      }
   }
} // end initialize constructor

// copy constructor
matrix::matrix (const matrix& m)
{
   row = m.row;
   col = m.col;
   for (int i = 0; i < row; i++)
   {
      for (int j=0; j < col; j++)
	 e[i][j]=m.e[i][j];
   }
}// end copy constructor

void matrix::input ()
{
   int x, y;
   char ans;
   do {
   cout << "\n\nMatrix Size:   x  ";
   x=wherex();
   y=wherey();
   gotoxy(x-5,y);
   cin >> row;
   gotoxy(x-1,y);
   cin >> col;
   cout << "[    ";
   for (int j=0; j<row; j++)
   {

      for (int i=0; i<col; i++)
      {
	 x=wherex();
	 y=wherey();
	 cin >> e[j][i];
	 gotoxy(x+5,y);
      }
      if (j<row-1)
	 cout << "\n     ";
   }
   cout << "]";

   cout << "\n\nRe-enter Matrix?  ";
   cin >> ans;
   } while ((ans=='y')||(ans=='Y'));

} // end input function


// output function
void matrix::output ()
{
   int x, y;
   cout << "[    ";
   for (int i=0; i < row; i++)
   {
      for (int j=0; j < col; j++)
      {
	 x = wherex();
	 y = wherey();

	 cout << e[i][j];
	 gotoxy (x+7, y);
      }
      if (i < row -1)
	 cout << "\n     ";
   }
   cout << ']' << '\n';
}

// creates n x n identity matrix
void matrix::identity(const int& n)
{
   row = n;
   col = n;
   for (int i = 0; i < n; i++)
   {
      for (int j = 0; j <= i; j++)
      {
	 if (j==i)
	    e[i][j]=1;
	 else
	    e[i][j]=0;
      }
   }
}

// does scaler multiplication
matrix matrix::s_mult(const double& x)
{
   matrix m;
   m.row = row;
   m.col = col;
   for (int i = 0; i < row; i++)
   {
      for (int j=0; j < col; j++)
	 m.e[i][j] = e[i][j]*x;
   }
   return m;
}

// adds two matricies as long as their dimensions are the same
matrix matrix::add(const matrix& m)
{
   matrix x;

   if ((m.row==row)&&(m.col==col))
   {
      x.row = row;
      x.col = col;
      for (int i = 0; i < row; i++)
      {
	 for (int j = 0; j < col; j++)
	    x.e[i][j]=e[i][j]+m.e[i][j];
      }

   } // end if statement

   return x;
}

matrix matrix::subtract(const matrix& m)
{
   matrix x;

   if ((m.row==row)&&(m.col==col))
   {
      x.row = row;
      x.col = col;
      for (int i = 0; i < row; i++)
      {
	 for (int j = 0; j < col; j++)
	    x.e[i][j]=e[i][j]-m.e[i][j];
      }

   } // end if statement

   return x;
}

matrix matrix::multiply(const matrix& m)
{
   matrix x;

   if (col==m.row)
   {
      x.col=m.col;
      x.row=row;
      for (int i = 0; i < x.row; i++)
      {
	 for (int j = 0; j < x.col; j++)
	 {
	    for (int z = 0; z < col; z++)
	       x.e[i][j] += e[i][z] * m.e[z][j];
	 }
      }

   } // end if statement

   return x;
} // end multiply function

// augment matrix function that serves no real purpose
// go random assignments
matrix matrix::augment(const matrix& m)
{
   matrix x;
   int i, j, l;

   if (row == m.row)
   {
      x.row = row;
      x.col = col + m.col;

      for (i=0; i<row; i++)
      {
	 for (j=0; j<col; j++)
	    x.e[i][j] = e[i][j];
      }

      for (i=0; i<row; i++)
      {
	 for (l=0; l<m.col; l++)
	    x.e[i][j+l] = m.e[i][l];
      }
   }

   return x;
} // end augment function

// overly complicated inverse function
matrix matrix::inverse()
{
   matrix x, m;
   double mult;

   // check for square matrix and check det
   if (row == col)//&&(det()!=0))
   {
      x.identity(row);
      copy(m);

      for (int i = 0; i < row; i++)
      {
	 if (e[i][i]==0.0)
	 {
	    findpivot(x, i);
	 }

	 rowdivide(i, e[i][i], x);

	 for (int j = 0; j<row; j++)
	 {
	    if (j == i)
	       j++;

	    mult = e[j][i]*-1;
	    for (int k = 0; k < col; k++)
	    {
	       e[j][k] += mult * e[i][k];
	       x.e[j][k] += mult * x.e[i][k];
	    }
	 }
      }

   revcopy(m); // returns base back to what it was
   }

   return x;
} // end inverse function (as if you were able to read all that)

// find pivot element for inverse function
void matrix::findpivot (matrix& m, int i)
{
   double x, z;

   for (int j=i; j<row, e[j][i]==0; j++);

   for (int k=0; k<col; k++)
   {
      x = e[j][k];
      e[j][k] = e[i][k];
      e[i][k] = x;

      z = m.e[j][k];
      m.e[j][k] = m.e[i][k];
      m.e[i][k] = z;
   }
} // finds pivot element for matrix and swaps the rows

// divides entire row by pivot element
void matrix::rowdivide(const int& i, double a, matrix& x)
{
   for (int j = 0; j < col; j++)
   {
      e[i][j]/=a;
      x.e[i][j]/=a;
   }
} // end row divide function

// coppies base to matrix
void matrix::copy (matrix& x)
{
   x.row = row;
   x.col = col;
   for (int i = 0; i < row; i++)
   {
      for (int j = 0; j < col; j++)
	 x.e[i][j]=e[i][j];
   }
}

// coppies matrix to base
void matrix::revcopy (matrix& x)
{
   row = x.row;
   col = x.col;
   for (int i = 0; i < row; i++)
   {
      for (int j = 0; j<col; j++)
	 e[i][j] = x.e[i][j];
   }
}

// holy crap, determinate thing ahead, close your eyes
double matrix::det(void)
{
   double result = 0;
   matrix m;
   int sign = 1;

   if (row != col)
      cout << "Determinat does not exist.";

   if (row == 2)
      result = e[0][0]*e[1][1] - e[0][1]*e[1][0];

   else
   {
      for (int i = 0; i < col; i++)
      {
	 m = minor(0,i);
	 result += sign * e[0][i] * m.det();
	 sign *= -1;
      }
   }
   return result;
} // understand that? neither did i.

// minor function
matrix matrix::minor (int r, int c)
{
   matrix x;
   int d1=0, d2=0;

   x.row = row - 1;
   x.col = col -1;

   for (int i = 0; i < row; i++)
   {
      if (i == r)
      {
	 i++;
	 d1 = -1;
      }

      for (int j = 0; j < col; j++)
      {
	 if (j == c)
	 {
	    j++;
	    d2 = -1;
	 }
	 x.e[i+d1][j+d2] = e[i][j];
      }
      d2 = 0;
   }

   return x;
}  // end too young to drink function