diff --git a/Matrix.cpp b/Matrix.cpp
index 0ade0d9..dcc08f4 100644
--- a/Matrix.cpp
+++ b/Matrix.cpp
@@ -6,7 +6,7 @@ void MatrixOf<float>::Transpose(MatrixOf<float>* r) {
   // We dont care about the rows and cols (we overwrite them)
   // but the data size should be equal to avoid problems
   // We cannot check the data size directly, but the row*col should be equal
-  int matrixSize = this->cols * this->rows;
+  unsigned int matrixSize = this->cols * this->rows;
   if (matrixSize != r->rows * r->cols)
     // Exception??? For now we don't do anything
     return;
@@ -15,9 +15,9 @@ void MatrixOf<float>::Transpose(MatrixOf<float>* r) {
   r->rows = this->cols;
 
   for (int rDataIx = 0; rDataIx < matrixSize; rDataIx++) {
-    int rowIx = rDataIx / this->rows;
-    int colIx = rDataIx % this->rows;
-    int mDataIx = this->cols * colIx + rowIx;
+    unsigned int rowIx = rDataIx / this->rows;
+    unsigned int colIx = rDataIx % this->rows;
+    unsigned int mDataIx = this->cols * colIx + rowIx;
     r->data[rDataIx] = this->data[mDataIx];
   }
 }
@@ -26,13 +26,13 @@ template <>
 void MatrixOf<float>::Multiply(MatrixOf<float>* m1,
                                MatrixOf<float>* m2,
                                MatrixOf<float>* r) {
-  for (int rowIx1 = 0; rowIx1 < m1->rows; rowIx1++) {
-    for (int colIx2 = 0; colIx2 < m2->cols; colIx2++) {
-      int rDataIx = colIx2 * m2->cols + rowIx1;
+  for (unsigned int rowIx1 = 0; rowIx1 < m1->rows; rowIx1++) {
+    for (unsigned int colIx2 = 0; colIx2 < m2->cols; colIx2++) {
+      unsigned int rDataIx = colIx2 * m2->cols + rowIx1;
       r->data[rDataIx] = 0.0F;
       for (int kIx = 0; kIx < m2->rows; kIx++) {
-        int dataIx1 = rowIx1 * m1->cols + kIx;
-        int dataIx2 = kIx * m2->cols + colIx2;
+        unsigned int dataIx1 = rowIx1 * m1->cols + kIx;
+        unsigned int dataIx2 = kIx * m2->cols + colIx2;
         r->data[rDataIx] += m1->data[dataIx1] * m2->data[dataIx2];
       }
     }
@@ -57,4 +57,20 @@ Vector3 MatrixOf<float>::Multiply(MatrixOf<float>* m, Vector3 v) {
   delete[] vData;
   delete[] rData;
   return r;
+}
+
+template <typename T>
+T MatrixOf<T>::Get(unsigned int rowIx, unsigned int colIx) {
+  unsigned int dataIx = rowIx * this->cols + colIx;
+  return this->data[dataIx];
+}
+
+template <typename T>
+unsigned int MatrixOf<T>::RowCount() {
+  return rows;
+}
+
+template <typename T>
+unsigned int MatrixOf<T>::ColCount() {
+  return cols;
 }
\ No newline at end of file
diff --git a/Matrix.h b/Matrix.h
index c4ed428..0648562 100644
--- a/Matrix.h
+++ b/Matrix.h
@@ -4,24 +4,30 @@
 #include "Vector3.h"
 
 /// @brief Single precision float matrix
-template <typename T> class MatrixOf {
-public:
-  MatrixOf(int rows, int cols, T *data) : rows(rows), cols(cols), data(data) {}
-  MatrixOf(Vector3 v); // creates a 3,1 matrix
+template <typename T>
+class MatrixOf {
+ public:
+  MatrixOf(unsigned int rows, unsigned int cols, T* data)
+      : rows(rows), cols(cols), data(data) {}
+  MatrixOf(Vector3 v);  // creates a 3,1 matrix
 
   /// @brief Transpose with result in matrix m
   /// @param r The matrix in which the transposed matrix is stored
-  void Transpose(MatrixOf<T> *r);
+  void Transpose(MatrixOf<T>* r);
 
-  static void Multiply(MatrixOf<T> *m1, MatrixOf<T> *m2, MatrixOf<T> *r);
-  void Multiply(MatrixOf<T> *m, MatrixOf<T> *r);
+  static void Multiply(MatrixOf<T>* m1, MatrixOf<T>* m2, MatrixOf<T>* r);
+  void Multiply(MatrixOf<T>* m, MatrixOf<T>* r);
 
-  static Vector3 Multiply(MatrixOf<T> *m, Vector3 v);
+  static Vector3 Multiply(MatrixOf<T>* m, Vector3 v);
 
-private:
-  int rows;
-  int cols;
-  T *data;
+  T Get(unsigned int rowIx, unsigned int colIx);
+  unsigned int RowCount();
+  unsigned int ColCount();
+
+ private:
+  unsigned int rows;
+  unsigned int cols;
+  T* data;
 };
 
 #endif
\ No newline at end of file
diff --git a/test/Matrix_test.cc b/test/Matrix_test.cc
index 48620df..c3b0de6 100644
--- a/test/Matrix_test.cc
+++ b/test/Matrix_test.cc
@@ -34,89 +34,89 @@ TEST(MatrixSingle, Transpose) {
 
   float data3[] = {1.0F, 2.0F, 3.0F, 4.0F};
   MatrixOf<float> m22 = MatrixOf<float>(2, 2, data3);
-  EXPECT_EQ(m22.rows, 2);
-  EXPECT_EQ(m22.cols, 2);
+  EXPECT_EQ(m22.RowCount(), 2);
+  EXPECT_EQ(m22.ColCount(), 2);
 
   float data4[] = {0.0F, 0.0F, 0.0F, 0.0F};
   MatrixOf<float> r22 = MatrixOf<float>(2, 2, data4);
-  EXPECT_EQ(r22.rows, 2);
-  EXPECT_EQ(r22.cols, 2);
+  EXPECT_EQ(r22.RowCount(), 2);
+  EXPECT_EQ(r22.ColCount(), 2);
 
   m22.Transpose(&r22);
-  EXPECT_EQ(r22.rows, 2);
-  EXPECT_EQ(r22.cols, 2);
-  EXPECT_FLOAT_EQ(r22.data[0], 1.0F);
-  EXPECT_FLOAT_EQ(r22.data[1], 3.0F);
-  EXPECT_FLOAT_EQ(r22.data[2], 2.0F);
-  EXPECT_FLOAT_EQ(r22.data[3], 4.0F);
+  EXPECT_EQ(r22.RowCount(), 2);
+  EXPECT_EQ(r22.ColCount(), 2);
+  EXPECT_FLOAT_EQ(r22.Get(0, 0), 1.0F);
+  EXPECT_FLOAT_EQ(r22.Get(0, 1), 3.0F);
+  EXPECT_FLOAT_EQ(r22.Get(1, 0), 2.0F);
+  EXPECT_FLOAT_EQ(r22.Get(1, 1), 4.0F);
 
   // 1 x 2
   float data12[] = {1.0F, 2.0F};
   MatrixOf<float> m12 = MatrixOf<float>(1, 2, data12);
-  EXPECT_EQ(m12.rows, 1);
-  EXPECT_EQ(m12.cols, 2);
+  EXPECT_EQ(m12.RowCount(), 1);
+  EXPECT_EQ(m12.ColCount(), 2);
 
   float data21[] = {0.0F, 0.0F};
   MatrixOf<float> r21 = MatrixOf<float>(2, 1, data21);
-  EXPECT_EQ(r21.rows, 2);
-  EXPECT_EQ(r21.cols, 1);
+  EXPECT_EQ(r21.RowCount(), 2);
+  EXPECT_EQ(r21.ColCount(), 1);
 
   m12.Transpose(&r21);
-  EXPECT_EQ(r21.rows, 2);
-  EXPECT_EQ(r21.cols, 1);
-  EXPECT_FLOAT_EQ(r21.data[0], 1.0F);
-  EXPECT_FLOAT_EQ(r21.data[1], 2.0F);
+  EXPECT_EQ(r21.RowCount(), 2);
+  EXPECT_EQ(r21.ColCount(), 1);
+  EXPECT_FLOAT_EQ(r21.Get(0, 0), 1.0F);
+  EXPECT_FLOAT_EQ(r21.Get(1, 0), 2.0F);
 
   // changing dimensions, same size is okay
   MatrixOf<float> r12 = MatrixOf<float>(1, 2, data21);
-  EXPECT_EQ(r12.rows, 1);
-  EXPECT_EQ(r12.cols, 2);
+  EXPECT_EQ(r12.RowCount(), 1);
+  EXPECT_EQ(r12.ColCount(), 2);
 
   m12.Transpose(&r12);
-  EXPECT_EQ(r12.rows, 2);
-  EXPECT_EQ(r12.cols, 1);
-  EXPECT_FLOAT_EQ(r12.data[0], 1.0F);
-  EXPECT_FLOAT_EQ(r12.data[1], 2.0F);
+  EXPECT_EQ(r12.RowCount(), 2);
+  EXPECT_EQ(r12.ColCount(), 1);
+  EXPECT_FLOAT_EQ(r12.Get(0, 0), 1.0F);
+  EXPECT_FLOAT_EQ(r12.Get(0, 1), 2.0F);
 }
 
 TEST(MatrixSingle, Multiply) {
   float m12data[] = {1.0F, 2.0F};
   MatrixOf<float> m12 = MatrixOf<float>(1, 2, m12data);
 
-  EXPECT_EQ(m12.rows, 1);
-  EXPECT_EQ(m12.cols, 2);
-  EXPECT_FLOAT_EQ(m12.data[0], 1.0F);
-  EXPECT_FLOAT_EQ(m12.data[1], 2.0F);
+  EXPECT_EQ(m12.RowCount(), 1);
+  EXPECT_EQ(m12.ColCount(), 2);
+  EXPECT_FLOAT_EQ(m12.Get(0, 0), 1.0F);
+  EXPECT_FLOAT_EQ(m12.Get(0, 1), 2.0F);
 
   float m21data[] = {3.0F, 4.0F};
   MatrixOf<float> m21 = MatrixOf<float>(2, 1, m21data);
 
-  EXPECT_EQ(m21.rows, 2);
-  EXPECT_EQ(m21.cols, 1);
-  EXPECT_FLOAT_EQ(m21.data[0], 3.0F);
-  EXPECT_FLOAT_EQ(m21.data[1], 4.0F);
+  EXPECT_EQ(m21.RowCount(), 2);
+  EXPECT_EQ(m21.ColCount(), 1);
+  EXPECT_FLOAT_EQ(m21.Get(0, 0), 3.0F);
+  EXPECT_FLOAT_EQ(m21.Get(1, 0), 4.0F);
 
   float r11data[] = {0.0F};
   MatrixOf<float> r11 = MatrixOf<float>(1, 1, r11data);
 
-  EXPECT_EQ(r11.rows, 1);
-  EXPECT_EQ(r11.cols, 1);
+  EXPECT_EQ(r11.RowCount(), 1);
+  EXPECT_EQ(r11.ColCount(), 1);
 
   MatrixOf<float>::Multiply(&m12, &m21, &r11);
-  EXPECT_EQ(r11.rows, 1);
-  EXPECT_EQ(r11.cols, 1);
-  EXPECT_FLOAT_EQ(r11.data[0], 11.0F);
+  EXPECT_EQ(r11.RowCount(), 1);
+  EXPECT_EQ(r11.ColCount(), 1);
+  EXPECT_FLOAT_EQ(r11.Get(0, 0), 11.0F);
 
   float r22data[] = {0.0F, 0.0F, 0.0F, 0.0F};
   MatrixOf<float> r22 = MatrixOf<float>(2, 2, r22data);
 
   MatrixOf<float>::Multiply(&m21, &m12, &r22);
-  EXPECT_EQ(r22.rows, 2);
-  EXPECT_EQ(r22.cols, 2);
-  EXPECT_FLOAT_EQ(r22.data[0], 3.0F);
-  EXPECT_FLOAT_EQ(r22.data[1], 4.0F);
-  EXPECT_FLOAT_EQ(r22.data[2], 6.0F);
-  EXPECT_FLOAT_EQ(r22.data[3], 8.0F);
+  EXPECT_EQ(r22.RowCount(), 2);
+  EXPECT_EQ(r22.ColCount(), 2);
+  EXPECT_FLOAT_EQ(r22.Get(0, 0), 3.0F);
+  EXPECT_FLOAT_EQ(r22.Get(0, 1), 4.0F);
+  EXPECT_FLOAT_EQ(r22.Get(1, 0), 6.0F);
+  EXPECT_FLOAT_EQ(r22.Get(1, 1), 8.0F);
 }
 
 #endif
\ No newline at end of file