diff --git a/matrix.cpp b/matrix.cpp
index abe8ecc..e0ac846 100644
--- a/matrix.cpp
+++ b/matrix.cpp
@@ -3,7 +3,7 @@
 int main() {
   vector a = vector(2);
   a[0] = cnumber(7, 0);
-  a[1] = cnumber(6, 0);
+  a[1] = cnumber(6, 1);
 
   vector b = vector(2);
   b[0] = cnumber(5, 0);
@@ -11,12 +11,12 @@ int main() {
 
   vector c = vector(2);
   c[0] = cnumber(2, 0);
-  c[1] = cnumber(5, 0);
+  c[1] = cnumber(1, 1);
 
 
   vector d = vector(2);
-  d[0] = cnumber(1, 0);
-  d[1] = cnumber(0, 1);
+  d[0] = cnumber(1, -1);
+  d[1] = cnumber(5, 0);
 
   matrix m = matrix(2, 2);
   m[0] = a;
@@ -28,6 +28,8 @@ int main() {
 
   cout << "The matrix m:" << endl;
   cout << m << endl;
+  cout << "The matrix m roted by one pi radian:" << endl;
+  cout << m.rotate_by_one_pi() << endl;
   cout << "The determinant of matrix m:" << endl;
   cout << m.determinant() << endl;
   cout << "The matrix m's transpose:" << endl;
@@ -47,8 +49,8 @@ int main() {
          << endl;
     cout << m.hermitian_conjugate() << endl;
   }
-  if  (!n.is_hermitian()) {
-    cout << "The matrix n is not hermitian, here is the hermitian conjugate:"
+  if  (n.is_hermitian()) {
+    cout << "The matrix n is hermitian, here is the hermitian conjugate:"
          << endl;
     cout << n.hermitian_conjugate() << endl;
   }
diff --git a/matrix.hpp b/matrix.hpp
index 5e4d9de..d64c240 100644
--- a/matrix.hpp
+++ b/matrix.hpp
@@ -6,103 +6,100 @@
 using namespace std;
 class matrix {
 private:
-  long long num_cols;
-  long long num_rows;
-  vector *cols;
+  long long num_entries;
+  long long entry_dimension;
+  vector *entries;
+  bool err;
 
 public:
-  matrix(const long long num_rows, const long long num_cols) {
-    this->num_cols = num_cols;
-    this->num_rows = num_rows;
-    this->cols = (vector *)calloc(sizeof(vector), num_cols);
-    for (long long i = 0; i < num_cols; i++) {
-      this->cols[i] = vector(num_rows);
+  matrix(const long long num_entries, const long long entry_dimension) {
+    this->num_entries = entry_dimension;
+    this->entry_dimension = num_entries;
+    this->err = false;
+    this->entries = (vector *)malloc(sizeof(vector) * this->num_entries);
+    for (long long i = 0; i < entry_dimension; i++) {
+      this->entries[i] = vector(this->entry_dimension);
     }
   }
   matrix(const matrix &m) {
-    this->num_cols = m.num_cols;
-    this->num_rows = m.num_rows;
-    this->cols = (vector *)calloc(sizeof(vector), m.num_cols);
-    for (long long i = 0; i < m.num_cols; i++) {
-      this->cols[i] = m[i];
+    this->num_entries = m.num_entries;
+    this->entry_dimension = m.entry_dimension;
+    this->err = m.err;
+    this->entries = (vector *)malloc(sizeof(vector) * m.num_entries);
+    for (long long i = 0; i < m.num_entries; i++) {
+      this->entries[i] = m[i];
     }
   }
   ~matrix() {
-    this->num_cols = 0;
-    this->num_rows = 0;
-    free(this->cols);
-    this->cols = NULL;
+    this->num_entries = 0;
+    this->entry_dimension = 0;
+    free(this->entries);
+    this->entries = NULL;
+    this->err = true;
   }
   const cnumber determinant() const {
-	  cnumber dsum(1,0);
-	  cnumber osum(1,0);
-	  vector diag = this->get_diagonal();
-	  vector odiag = this->get_off_diagonal();
-	  for (long long i = 0; i < diag.get_dimention(); i++) {
-		  dsum = dsum * diag[i];
-		  osum = osum * odiag[i];
-	  }
-	  return dsum - osum;
+    cnumber dsum(1, 0);
+    cnumber osum(1, 0);
+    vector diag = this->get_diagonal();
+    vector odiag = this->get_off_diagonal();
+    for (long long i = 0; i < diag.get_dimention(); i++) {
+      dsum = dsum * diag[i];
+      osum = osum * odiag[i];
+    }
+    return dsum - osum;
   }
   const vector get_diagonal() const {
-    long long diag_len = this->num_rows;
-    if (this->num_cols < diag_len) {
-      diag_len = this->num_cols;
+    long long diag_len = this->entry_dimension;
+    if (this->num_entries < diag_len) {
+      diag_len = this->num_entries;
     }
     vector v(diag_len);
-    for (long long i = 0; i < this->num_cols; i++) {
-      for (long long j = 0; j < this->num_rows; j++) {
+    for (long long i = 0; i < this->num_entries; i++) {
+      for (long long j = 0; j < this->entry_dimension; j++) {
         if (i == j) {
-          v[i] = this->cols[i][j];
+          v[i] = this->entries[i][j];
         }
       }
     }
     return v;
   }
   const vector get_off_diagonal() const {
-    long long diag_len = this->num_rows;
-    if (this->num_cols < diag_len) {
-      diag_len = this->num_cols;
-    }
-    vector v(diag_len);
-    for (long long i = 0; i < this->num_cols; i++) {
-      for (long long j = 0; j < this->num_rows; j++) {
-        if (i + j == this->num_rows - 1) {
-          v[i] = this->cols[i][j];
-        }
-      }
-    }
-    return v;
+    return this->rotate_by_one_pi().get_diagonal();
   }
-  const vector get_row(long long index) const { return this->cols[index]; }
+  const vector get_entry(long long index) const { return this->entries[index]; }
 
-  const vector get_column(long long index) const {
-    vector v(this->num_rows);
-    for (long long j = 0; j < this->num_rows; j++) {
-      v[j] = this->cols[j][index];
+  const vector get_row(long long index) const {
+    vector v(this->entry_dimension);
+    for (long long j = 0; j < this->entry_dimension; j++) {
+      v[j] = this->entries[j][index];
     }
     return v;
   }
 
-  const matrix rotate_ninety() const {
-    matrix m(this->num_cols, this->num_rows);
-    return m;
+  const matrix rotate_by_one_pi() const {
+    matrix m = this->transpose();
+    matrix n = matrix(m.entry_dimension, m.num_entries);
+    for (long long i = 0; i < m.entry_dimension; i++) {
+      int index = m.num_entries - i - 1;
+      n[i] = m[index];
+    }
+    return n;
   }
   const matrix transpose() const {
-    matrix n(this->num_rows, this->num_cols);
-    for (long long i = 0; i < this->num_cols; i++) {
-      for (long long j = 0; j < this->num_rows; j++) {
-        n[j][i] = this->cols[i][j];
+    matrix n = matrix(this->entry_dimension, this->num_entries);
+    for (long long i = 0; i < this->num_entries; i++) {
+      for (long long j = 0; j < this->entry_dimension; j++) {
+        n[j][i] = this->entries[i][j];
       }
     }
 
     return n;
   }
   const matrix conjugate() const {
-    matrix n(this->num_cols, this->num_rows);
-    for (long long i = 0; i < this->num_cols; i++) {
-      for (long long j = 0; j < this->num_rows; j++) {
-        n[i][j] = this->cols[i][j].conjugate();
+    matrix n = matrix(this->num_entries, this->entry_dimension);
+    for (long long i = 0; i < this->num_entries; i++) {
+      for (long long j = 0; j < this->entry_dimension; j++) {
+        n[i][j] = this->entries[i][j].conjugate();
       }
     }
 
@@ -112,13 +109,13 @@ public:
     return this->transpose().conjugate();
   }
   const bool is_hermitian() const {
-    if (this->num_rows != this->num_cols)
+    if (this->entry_dimension != this->num_entries)
       return false;
     matrix m = this->hermitian_conjugate();
     bool equal = true;
-    for (long long i = 0; i < m.num_cols; i++) {
-      for (long long j = 0; j < m.num_rows; j++) {
-        if (m[i][j] != this->cols[i][j]) {
+    for (long long i = 0; i < m.num_entries; i++) {
+      for (long long j = 0; j < m.entry_dimension; j++) {
+        if (m[i][j] != this->entries[i][j]) {
           equal = false;
         }
       }
@@ -127,12 +124,12 @@ public:
   }
   friend ostream &operator<<(ostream &os, const matrix &m) {
     char last = '\0';
-    for (long long i = 0; i < m.num_cols; i++) {
-      for (long long j = 0; j < m.num_rows; j++) {
+    for (long long i = 0; i < m.num_entries; i++) {
+      for (long long j = 0; j < m.entry_dimension; j++) {
         string symbols[3];
         symbols[0] = "|";
         ostringstream oss;
-        oss << " " << m.cols[i][j] << " ";
+        oss << " " << m.entries[i][j] << " ";
         symbols[1] = oss.str();
         symbols[2] = "|";
         for (int i = 0; i < 3; i++) {
@@ -144,40 +141,44 @@ public:
           last = symbols[i][len];
         }
       }
-      if (i != m.num_cols - 1)
+      if (i != m.num_entries - 1)
         os << endl << "|";
     }
     return os;
   }
   const bool operator==(const matrix &m) const {
     bool equal = true;
-    for (long long i = 0; i < this->num_cols; i++) {
-      for (long long j = 0; j < this->num_rows; j++) {
-        if (this->cols[i][j] != m[i][j]) {
+    for (long long i = 0; i < this->num_entries; i++) {
+      for (long long j = 0; j < this->entry_dimension; j++) {
+        if (this->entries[i][j] != m[i][j]) {
           equal = false;
         }
       }
     }
     return equal;
   }
+  vector &operator[](const long long index) { return this->entries[index]; }
   const vector operator[](const long long index) const {
-    return this->cols[index];
+    return this->entries[index];
   }
   const matrix operator*(const cnumber z) const {
-    matrix n(this->num_cols, this->num_rows);
-    for (long long i = 0; i < this->num_cols; i++) {
-      n[i] = this->cols[i] * z;
+    matrix n(this->num_entries, this->entry_dimension);
+    for (long long i = 0; i < this->num_entries; i++) {
+      n[i] = this->entries[i] * z;
     }
 
     return n;
   }
   const matrix operator*(const matrix m) const {
-    matrix n(this->num_cols, m.num_rows);
-    // if (this->num_cols != m.num_rows && m.num_cols != this->num_rows)
-    //   return n;
-    for (long long i = 0; i < this->num_rows; i++) {
-      for (long long j = 0; j < this->num_rows; j++) {
-        n[i][j] = this->get_row(i) * m.get_column(j);
+    matrix n(this->num_entries, m.entry_dimension);
+    if (this->num_entries != m.entry_dimension &&
+        m.num_entries != this->entry_dimension) {
+      n.err = true;
+      return n;
+    }
+    for (long long i = 0; i < this->entry_dimension; i++) {
+      for (long long j = 0; j < this->entry_dimension; j++) {
+        n[i][j] = this->get_entry(i) * m.get_row(j);
       }
     }
 
@@ -185,22 +186,28 @@ public:
   }
 
   const matrix operator+(const matrix &m) const {
-    matrix n(this->num_cols, this->num_rows);
-    for (long long i = 0; i < this->num_cols; i++) {
-      n[i] = this->cols[i] + m[i];
+    matrix n(this->num_entries, this->entry_dimension);
+    for (long long i = 0; i < this->num_entries; i++) {
+      n[i] = this->entries[i] + m[i];
     }
 
     return n;
   }
   const matrix operator-(const matrix &m) const {
-    matrix n(this->num_cols, this->num_rows);
-    for (long long i = 0; i < this->num_cols; i++) {
-      n[i] = this->cols[i] - m[i];
+    matrix n(this->num_entries, this->entry_dimension);
+    for (long long i = 0; i < this->num_entries; i++) {
+      n[i] = this->entries[i] - m[i];
     }
 
     return n;
   }
-  // FIXME: Figure out how to make sure you do not try to access something
-  // outside of the index
-  vector &operator[](const long long index) { return this->cols[index]; }
+  void operator=(const matrix &m) {
+    this->num_entries = m.num_entries;
+    this->entry_dimension = m.entry_dimension;
+    this->err = m.err;
+    free(this->entries);
+    this->entries = (vector *)malloc(sizeof(vector) * m.num_entries);
+    for (long long i = 0; i < m.num_entries; i++)
+      this->entries[i] = m[i];
+  }
 };