#if GTEST
#include <gtest/gtest.h>
#include <math.h>
#include <limits>

#include "Matrix.h"

TEST(MatrixSingle, Init) {
  // zero
  float data0[] = {};
  MatrixOf<float> m0 = MatrixOf<float>(0, 0, data0);

  // one
  float data1[] = {1.0F};
  MatrixOf<float> m1 = MatrixOf<float>(1, 1, data1);

  // two
  float data2[] = {1.0F, 2.0F, 3.0F, 4.0F};
  MatrixOf<float> m2 = MatrixOf<float>(2, 2, data2);

  // negative
  MatrixOf<float> m_1 = MatrixOf<float>(-1, -1, data0);
}

TEST(MatrixSingle, Transpose) {
  float data1[] = {1.0F};
  MatrixOf<float> m = MatrixOf<float>(1, 1, data1);

  float data2[] = {1.0F};
  MatrixOf<float> r = MatrixOf<float>(1, 1, data2);
  m.Transpose(&r);

  // 2 x 2

  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);

  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);

  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);

  // 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);

  float data21[] = {0.0F, 0.0F};
  MatrixOf<float> r21 = MatrixOf<float>(2, 1, data21);
  EXPECT_EQ(r21.rows, 2);
  EXPECT_EQ(r21.cols, 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);

  // changing dimensions, same size is okay
  MatrixOf<float> r12 = MatrixOf<float>(1, 2, data21);
  EXPECT_EQ(r12.rows, 1);
  EXPECT_EQ(r12.cols, 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);
}

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);

  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);

  float r11data[] = {0.0F};
  MatrixOf<float> r11 = MatrixOf<float>(1, 1, r11data);

  EXPECT_EQ(r11.rows, 1);
  EXPECT_EQ(r11.cols, 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);

  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);
}

#endif