KOKO\Mimi
114 lines
3.5 KiB
C++
114 lines
3.5 KiB
C++
#include "fesa/math/matrix.h"
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#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);
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace fesa
|