FESADev/tests/unit/math/matrix_test.cpp

#include "fesa/math/matrix.h"

#include <gtest/gtest.h>

#include <cmath>
#include <limits>
#include <stdexcept>
#include <utility>

namespace fesa {
namespace {

TEST(DenseMath, RowMajorMatrixMatchesKnownGemvGemm) {
  const std::size_t wraparound_rows =
      (std::numeric_limits<std::size_t>::max)() / 2U + 1U;
  EXPECT_THROW(static_cast<void>(Matrix{wraparound_rows, 2}),
               std::length_error);

  Matrix zero_rows{0, 3};
  Vector three_values{3, 2.0};
  const Vector zero_row_product = zero_rows.Multiply(three_values);
  EXPECT_EQ(zero_row_product.Size(), 0U);

  Matrix zero_columns{2, 0};
  const Vector zero_column_product = zero_columns.Multiply(Vector{0});
  ASSERT_EQ(zero_column_product.Size(), 2U);
  EXPECT_DOUBLE_EQ(zero_column_product[0], 0.0);
  EXPECT_DOUBLE_EQ(zero_column_product[1], 0.0);

  Matrix zero_inner_right{0, 3};
  const Matrix zero_inner_product = zero_columns.Multiply(zero_inner_right);
  EXPECT_EQ(zero_inner_product.Rows(), 2U);
  EXPECT_EQ(zero_inner_product.Columns(), 3U);
  for (std::size_t row = 0; row < zero_inner_product.Rows(); ++row) {
    for (std::size_t column = 0; column < zero_inner_product.Columns();
         ++column) {
      EXPECT_DOUBLE_EQ(zero_inner_product(row, column), 0.0);
    }
  }

  Matrix left{2, 3};
  left(0, 0) = 1.0;
  left(0, 1) = 2.0;
  left(0, 2) = 3.0;
  left(1, 0) = 4.0;
  left(1, 1) = 5.0;
  left(1, 2) = 6.0;

  EXPECT_EQ(&left(0, 0) + 1, &left(0, 1));
  EXPECT_EQ(&left(0, 0) + 2, &left(0, 2));
  EXPECT_EQ(&left(0, 0) + 3, &left(1, 0));
  const Matrix& const_left = left;
  EXPECT_DOUBLE_EQ(const_left(1, 2), 6.0);

  Matrix copied{left};
  copied(0, 0) = 42.0;
  EXPECT_DOUBLE_EQ(left(0, 0), 1.0);

  Matrix copy_assigned{0, 0};
  copy_assigned = left;
  copy_assigned(1, 2) = -7.0;
  EXPECT_DOUBLE_EQ(left(1, 2), 6.0);

  Matrix moved{std::move(copied)};
  EXPECT_EQ(copied.Rows(), 0U);
  EXPECT_EQ(copied.Columns(), 0U);
  EXPECT_EQ(moved.Rows(), 2U);
  EXPECT_EQ(moved.Columns(), 3U);
  EXPECT_DOUBLE_EQ(moved(0, 0), 42.0);
  EXPECT_NO_THROW(static_cast<void>(copied.Multiply(Vector{0})));

  Matrix move_assigned{1, 1, -1.0};
  move_assigned = std::move(copy_assigned);
  EXPECT_EQ(copy_assigned.Rows(), 0U);
  EXPECT_EQ(copy_assigned.Columns(), 0U);
  EXPECT_EQ(move_assigned.Rows(), 2U);
  EXPECT_EQ(move_assigned.Columns(), 3U);
  EXPECT_DOUBLE_EQ(move_assigned(1, 2), -7.0);

  Vector vector{3};
  vector[0] = 7.0;
  vector[1] = 8.0;
  vector[2] = 9.0;
  const Vector matrix_vector_product = left.Multiply(vector);
  ASSERT_EQ(matrix_vector_product.Size(), 2U);
  EXPECT_DOUBLE_EQ(matrix_vector_product[0], 50.0);
  EXPECT_DOUBLE_EQ(matrix_vector_product[1], 122.0);

  Matrix right{3, 2};
  right(0, 0) = 7.0;
  right(0, 1) = 8.0;
  right(1, 0) = 9.0;
  right(1, 1) = 10.0;
  right(2, 0) = 11.0;
  right(2, 1) = 12.0;
  const Matrix matrix_product = left.Multiply(right);
  ASSERT_EQ(matrix_product.Rows(), 2U);
  ASSERT_EQ(matrix_product.Columns(), 2U);
  EXPECT_DOUBLE_EQ(matrix_product(0, 0), 58.0);
  EXPECT_DOUBLE_EQ(matrix_product(0, 1), 64.0);
  EXPECT_DOUBLE_EQ(matrix_product(1, 0), 139.0);
  EXPECT_DOUBLE_EQ(matrix_product(1, 1), 154.0);

  EXPECT_THROW(static_cast<void>(left(2, 0)), std::out_of_range);
  EXPECT_THROW(static_cast<void>(left(0, 3)), std::out_of_range);
  EXPECT_THROW(static_cast<void>(const_left(2, 0)), std::out_of_range);
  EXPECT_THROW(static_cast<void>(left.Multiply(Vector{2})),
               std::invalid_argument);
  EXPECT_THROW(static_cast<void>(left.Multiply(Matrix{4, 1})),
               std::invalid_argument);
}


TEST(DenseMath, MatrixContiguousScaleAndRobustNorm) {
  Matrix matrix{2U, 3U};
  const double entries[]{1.0, -2.0, 3.0, -4.0, 5.0, -6.0};
  for (std::size_t i = 0; i < 6U; ++i) matrix.Data()[i] = entries[i];
  const Matrix& immutable = matrix;
  EXPECT_EQ(immutable.Data() + 3, &immutable(1U, 0U));
  EXPECT_NEAR(matrix.Norm(), std::sqrt(91.0), 2.0e-15);
  matrix.Scale(-2.0);
  for (std::size_t i = 0; i < 6U; ++i)
    EXPECT_DOUBLE_EQ(matrix.Data()[i], -2.0 * entries[i]);
  EXPECT_DOUBLE_EQ(immutable(1U, 2U), 12.0);
  Matrix huge{1U, 2U, 1.0e308};
  EXPECT_NEAR(huge.Norm() / 1.0e308, std::sqrt(2.0), 4.0e-16);
  Matrix tiny{2U, 1U, 1.0e-300};
  EXPECT_NEAR(tiny.Norm() / 1.0e-300, std::sqrt(2.0), 4.0e-16);
  Matrix empty{0U, (std::numeric_limits<std::size_t>::max)()};
  EXPECT_DOUBLE_EQ(empty.Norm(), 0.0);
  EXPECT_NO_THROW(empty.Scale(3.0));
}

TEST(DenseMath, MatrixProductKeepsShapeAndFiniteValidationOrder) {
  const double nan = (std::numeric_limits<double>::quiet_NaN)();
  Matrix matrix{1U, 2U, nan};
  try {
    static_cast<void>(matrix.Multiply(Vector{1U}));
    FAIL() << "Shape mismatch was accepted";
  } catch (const std::invalid_argument& failure) {
    EXPECT_STREQ(failure.what(),
                 "Matrix-vector multiplication has incompatible dimensions.");
  }
  EXPECT_THROW(static_cast<void>(matrix.Multiply(Vector{2U})),
               std::invalid_argument);
  EXPECT_THROW(static_cast<void>(matrix.Multiply(Matrix{2U, 0U})),
               std::invalid_argument);
  EXPECT_THROW(static_cast<void>(Matrix{0U, 2U}.Multiply(Vector{2U, nan})),
               std::invalid_argument);
  const Matrix finite{2U, 2U, 3.0};
  const auto square = finite.Multiply(finite);
  EXPECT_DOUBLE_EQ(square(0U, 0U), 18.0);
  EXPECT_DOUBLE_EQ(finite(0U, 0U), 3.0);
}

TEST(DenseMath, MatrixSelfAssignmentPreservesShapeAndStorage) {
  Matrix matrix{2U, 1U, 7.0};
  const Matrix* same = &matrix;
  matrix = *same;
  EXPECT_EQ(matrix.Rows(), 2U);
  EXPECT_EQ(matrix.Columns(), 1U);
  EXPECT_DOUBLE_EQ(matrix(1U, 0U), 7.0);
  Matrix* mutable_same = &matrix;
  matrix = std::move(*mutable_same);
  EXPECT_EQ(matrix.Rows(), 2U);
  EXPECT_DOUBLE_EQ(matrix(1U, 0U), 7.0);
}

}  // namespace
TEST(DenseMath, MatrixProductsRejectNonfiniteOperandsAndPreserveValidReuse) {
  Matrix left{2U, 2U, 1.0};
  Matrix right{2U, 1U, 2.0};
  Vector rhs{2U, 2.0};
  rhs[1U] = std::numeric_limits<double>::infinity();
  EXPECT_THROW(static_cast<void>(left.Multiply(rhs)), std::invalid_argument);
  rhs[1U] = 2.0;
  left(0U, 1U) = std::numeric_limits<double>::quiet_NaN();
  EXPECT_THROW(static_cast<void>(left.Multiply(rhs)), std::invalid_argument);
  EXPECT_THROW(static_cast<void>(left.Multiply(right)), std::invalid_argument);
  left(0U, 1U) = 1.0;
  right(1U, 0U) = std::numeric_limits<double>::infinity();
  EXPECT_THROW(static_cast<void>(left.Multiply(right)), std::invalid_argument);
  right(1U, 0U) = 2.0;
  EXPECT_DOUBLE_EQ(left.Multiply(rhs)[0U], 4.0);
  EXPECT_DOUBLE_EQ(left.Multiply(right)(1U, 0U), 4.0);
}
}  // namespace fesa