KOKO\Mimi
115 lines
3.3 KiB
C++
115 lines
3.3 KiB
C++
#include "fesa/math/vector.h"
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include <stdexcept>
|
|
#include <utility>
|
|
|
|
namespace fesa {
|
|
namespace {
|
|
|
|
TEST(DenseMath, VectorOwnsAndChecksContiguousStorage) {
|
|
Vector empty{0};
|
|
EXPECT_EQ(empty.Size(), 0U);
|
|
EXPECT_DOUBLE_EQ(empty.Norm(), 0.0);
|
|
EXPECT_NO_THROW(empty.Scale(3.0));
|
|
EXPECT_NO_THROW(empty.Axpy(-2.0, Vector{0}));
|
|
EXPECT_THROW(static_cast<void>(empty[0]), std::out_of_range);
|
|
|
|
Vector original{3};
|
|
original[0] = 1.0;
|
|
original[1] = -2.0;
|
|
original[2] = 3.0;
|
|
|
|
EXPECT_EQ(original.Data() + 1, &original[1]);
|
|
EXPECT_EQ(original.Data() + 2, &original[2]);
|
|
const Vector& const_original = original;
|
|
EXPECT_EQ(const_original.Data() + 2, &const_original[2]);
|
|
|
|
Vector copied{original};
|
|
EXPECT_NE(copied.Data(), original.Data());
|
|
copied[0] = 99.0;
|
|
EXPECT_DOUBLE_EQ(original[0], 1.0);
|
|
|
|
Vector copy_assigned{0};
|
|
copy_assigned = original;
|
|
EXPECT_NE(copy_assigned.Data(), original.Data());
|
|
copy_assigned[1] = 17.0;
|
|
EXPECT_DOUBLE_EQ(original[1], -2.0);
|
|
|
|
Vector moved{std::move(copied)};
|
|
EXPECT_EQ(copied.Size(), 0U);
|
|
EXPECT_EQ(moved.Size(), 3U);
|
|
EXPECT_DOUBLE_EQ(moved[0], 99.0);
|
|
EXPECT_NO_THROW(copied.Scale(4.0));
|
|
|
|
Vector move_assigned{1, -1.0};
|
|
move_assigned = std::move(copy_assigned);
|
|
EXPECT_EQ(copy_assigned.Size(), 0U);
|
|
EXPECT_EQ(move_assigned.Size(), 3U);
|
|
EXPECT_DOUBLE_EQ(move_assigned[1], 17.0);
|
|
|
|
Vector rhs{3};
|
|
rhs[0] = 4.0;
|
|
rhs[1] = 5.0;
|
|
rhs[2] = -6.0;
|
|
EXPECT_DOUBLE_EQ(original.Dot(rhs), -24.0);
|
|
EXPECT_NEAR(original.Norm(), std::sqrt(14.0), 1.0e-15);
|
|
|
|
Vector scaled{original};
|
|
scaled.Scale(-0.5);
|
|
EXPECT_DOUBLE_EQ(scaled[0], -0.5);
|
|
EXPECT_DOUBLE_EQ(scaled[1], 1.0);
|
|
EXPECT_DOUBLE_EQ(scaled[2], -1.5);
|
|
|
|
Vector accumulated{3};
|
|
accumulated[0] = 1.0;
|
|
accumulated[1] = 2.0;
|
|
accumulated[2] = 3.0;
|
|
Vector increment{3};
|
|
increment[0] = 4.0;
|
|
increment[1] = -1.0;
|
|
increment[2] = 0.5;
|
|
accumulated.Axpy(2.0, increment);
|
|
EXPECT_DOUBLE_EQ(accumulated[0], 9.0);
|
|
EXPECT_DOUBLE_EQ(accumulated[1], 0.0);
|
|
EXPECT_DOUBLE_EQ(accumulated[2], 4.0);
|
|
|
|
EXPECT_THROW(static_cast<void>(original[3]), std::out_of_range);
|
|
EXPECT_THROW(static_cast<void>(const_original[3]), std::out_of_range);
|
|
EXPECT_THROW(static_cast<void>(original.Dot(Vector{2})),
|
|
std::invalid_argument);
|
|
EXPECT_THROW(original.Axpy(1.0, Vector{2}), std::invalid_argument);
|
|
}
|
|
|
|
|
|
TEST(DenseMath, VectorRobustNormSelfAliasAndNonfinitePropagation) {
|
|
Vector large{2U, 1.0e308};
|
|
EXPECT_NEAR(large.Norm() / 1.0e308, std::sqrt(2.0), 4.0e-16);
|
|
Vector tiny{2U, 1.0e-300};
|
|
EXPECT_NEAR(tiny.Norm() / 1.0e-300, std::sqrt(2.0), 4.0e-16);
|
|
Vector values{2U};
|
|
values[0] = 2.0;
|
|
values[1] = -3.0;
|
|
values.Axpy(-2.0, values);
|
|
EXPECT_DOUBLE_EQ(values[0], -2.0);
|
|
EXPECT_DOUBLE_EQ(values[1], 3.0);
|
|
const Vector* same = &values;
|
|
values = *same;
|
|
Vector* mutable_same = &values;
|
|
values = std::move(*mutable_same);
|
|
EXPECT_DOUBLE_EQ(values.Dot(values), 13.0);
|
|
Vector nonfinite{1U, (std::numeric_limits<double>::quiet_NaN)()};
|
|
EXPECT_TRUE(std::isnan(nonfinite.Dot(Vector{1U, 1.0})));
|
|
EXPECT_TRUE(std::isnan(nonfinite.Norm()));
|
|
EXPECT_NO_THROW(nonfinite.Scale(2.0));
|
|
EXPECT_NO_THROW(nonfinite.Axpy(1.0, Vector{1U, 1.0}));
|
|
EXPECT_TRUE(std::isnan(nonfinite[0]));
|
|
EXPECT_DOUBLE_EQ(Vector{0U}.Dot(Vector{0U}), 0.0);
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace fesa
|