baram2584/FESADev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(cpp-object-oriented-modular-refactoring): step 3 - foundation-google-style

Browse Source
This commit is contained in:
KOKO\Mimi
2026-08-16 04:26:14 +09:00
parent 2628ed3488
commit 042edadffb
93 changed files with 3144 additions and 3175 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit/math/matrix_test.cpp
+87 -83
View File
@@ -1,4 +1,4 @@
#include "fesa/math/matrix.hpp"
#include "fesa/math/matrix.h"
#include <gtest/gtest.h>
@@ -10,100 +10,104 @@ namespace fesa {
namespace {
TEST(DenseMath, RowMajorMatrixMatchesKnownGemvGemm) {
const std::size_t wraparoundRows =
(std::numeric_limits<std::size_t>::max)() / 2U + 1U;
EXPECT_THROW(static_cast<void>(Matrix{wraparoundRows, 2}), std::length_error);
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 zeroRows{0, 3};
Vector threeValues{3, 2.0};
const Vector zeroRowProduct = zeroRows.multiply(threeValues);
EXPECT_EQ(zeroRowProduct.size(), 0U);
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 zeroColumns{2, 0};
const Vector zeroColumnProduct = zeroColumns.multiply(Vector{0});
ASSERT_EQ(zeroColumnProduct.size(), 2U);
EXPECT_DOUBLE_EQ(zeroColumnProduct[0], 0.0);
EXPECT_DOUBLE_EQ(zeroColumnProduct[1], 0.0);
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 zeroInnerRight{0, 3};
const Matrix zeroInnerProduct = zeroColumns.multiply(zeroInnerRight);
EXPECT_EQ(zeroInnerProduct.rows(), 2U);
EXPECT_EQ(zeroInnerProduct.columns(), 3U);
for (std::size_t row = 0; row < zeroInnerProduct.rows(); ++row) {
for (std::size_t column = 0; column < zeroInnerProduct.columns(); ++column) {
EXPECT_DOUBLE_EQ(zeroInnerProduct(row, column), 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;
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& constLeft = left;
EXPECT_DOUBLE_EQ(constLeft(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 copied{left};
copied(0, 0) = 42.0;
EXPECT_DOUBLE_EQ(left(0, 0), 1.0);
Matrix copyAssigned{0, 0};
copyAssigned = left;
copyAssigned(1, 2) = -7.0;
EXPECT_DOUBLE_EQ(left(1, 2), 6.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 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 moveAssigned{1, 1, -1.0};
moveAssigned = std::move(copyAssigned);
EXPECT_EQ(copyAssigned.rows(), 0U);
EXPECT_EQ(copyAssigned.columns(), 0U);
EXPECT_EQ(moveAssigned.rows(), 2U);
EXPECT_EQ(moveAssigned.columns(), 3U);
EXPECT_DOUBLE_EQ(moveAssigned(1, 2), -7.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 matrixVectorProduct = left.multiply(vector);
ASSERT_EQ(matrixVectorProduct.size(), 2U);
EXPECT_DOUBLE_EQ(matrixVectorProduct[0], 50.0);
EXPECT_DOUBLE_EQ(matrixVectorProduct[1], 122.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 matrixProduct = left.multiply(right);
ASSERT_EQ(matrixProduct.rows(), 2U);
ASSERT_EQ(matrixProduct.columns(), 2U);
EXPECT_DOUBLE_EQ(matrixProduct(0, 0), 58.0);
EXPECT_DOUBLE_EQ(matrixProduct(0, 1), 64.0);
EXPECT_DOUBLE_EQ(matrixProduct(1, 0), 139.0);
EXPECT_DOUBLE_EQ(matrixProduct(1, 1), 154.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>(constLeft(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);
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
} // namespace
} // namespace fesa
tests/unit/math/sparse_matrix_test.cpp
+95 -110
View File
@@ -1,6 +1,4 @@
#include "fesa/fem/dof_manager.hpp"
#include "fesa/math/matrix.hpp"
#include "fesa/math/sparse_matrix.hpp"
#include "fesa/math/sparse_matrix.h"
#include <gtest/gtest.h>
@@ -10,6 +8,9 @@
#include <utility>
#include <vector>
#include "fesa/fem/dof_manager.hpp"
#include "fesa/math/matrix.h"
namespace {
using fesa::CooContribution;
@@ -22,128 +23,112 @@ static_assert(
"SparseMatrix must own CSR storage independently of dense Matrix.");
TEST(SparseAssembly, ValidatesKnownCsrAndMultiply) {
const SparsePattern pattern{
{0U, 2U, 2U, 4U, 5U},
{0U, 2U, 1U, 3U, 3U}};
std::vector<CooContribution> contributions{
{2U, 3U, 4.0, 2U, 0U},
{0U, 2U, 2.0, 0U, 1U},
{3U, 3U, 5.0, 3U, 0U},
{0U, 0U, 1.0, 0U, 0U},
{2U, 1U, 3.0, 1U, 0U}};
const SparsePattern pattern{{0U, 2U, 2U, 4U, 5U}, {0U, 2U, 1U, 3U, 3U}};
std::vector<CooContribution> contributions{{2U, 3U, 4.0, 2U, 0U},
{0U, 2U, 2.0, 0U, 1U},
{3U, 3U, 5.0, 3U, 0U},
{0U, 0U, 1.0, 0U, 0U},
{2U, 1U, 3.0, 1U, 0U}};
auto result = SparseMatrix::fromCoo(
4U, 4U, std::move(contributions), pattern);
ASSERT_TRUE(result.hasValue());
const SparseMatrix& matrix = result.value();
auto result =
SparseMatrix::FromCoo(4U, 4U, std::move(contributions), pattern);
ASSERT_TRUE(result.HasValue());
const SparseMatrix& matrix = result.Value();
EXPECT_EQ(matrix.rows(), 4U);
EXPECT_EQ(matrix.columns(), 4U);
EXPECT_EQ(matrix.rowOffsets(), pattern.rowOffsets);
EXPECT_EQ(matrix.columnIndices(), pattern.columnIndices);
EXPECT_EQ(matrix.values(), (std::vector<double>{1.0, 2.0, 3.0, 4.0, 5.0}));
EXPECT_TRUE(matrix.validate().isOk());
EXPECT_EQ(matrix.Rows(), 4U);
EXPECT_EQ(matrix.Columns(), 4U);
EXPECT_EQ(matrix.RowOffsets(), pattern.rowOffsets);
EXPECT_EQ(matrix.ColumnIndices(), pattern.columnIndices);
EXPECT_EQ(matrix.Values(), (std::vector<double>{1.0, 2.0, 3.0, 4.0, 5.0}));
EXPECT_TRUE(matrix.Validate().IsOk());
Vector rhs{4U};
rhs[0U] = 1.0;
rhs[1U] = 2.0;
rhs[2U] = 3.0;
rhs[3U] = 4.0;
const Vector product = matrix.multiply(rhs);
ASSERT_EQ(product.size(), 4U);
EXPECT_DOUBLE_EQ(product[0U], 7.0);
EXPECT_DOUBLE_EQ(product[1U], 0.0);
EXPECT_DOUBLE_EQ(product[2U], 22.0);
EXPECT_DOUBLE_EQ(product[3U], 20.0);
EXPECT_THROW(static_cast<void>(matrix.multiply(Vector{3U})), std::invalid_argument);
Vector rhs{4U};
rhs[0U] = 1.0;
rhs[1U] = 2.0;
rhs[2U] = 3.0;
rhs[3U] = 4.0;
const Vector product = matrix.Multiply(rhs);
ASSERT_EQ(product.Size(), 4U);
EXPECT_DOUBLE_EQ(product[0U], 7.0);
EXPECT_DOUBLE_EQ(product[1U], 0.0);
EXPECT_DOUBLE_EQ(product[2U], 22.0);
EXPECT_DOUBLE_EQ(product[3U], 20.0);
EXPECT_THROW(static_cast<void>(matrix.Multiply(Vector{3U})),
std::invalid_argument);
}
TEST(SparseAssembly, ReducesDuplicatesInFixedTupleOrder) {
const SparsePattern pattern{{0U, 1U}, {0U}};
const std::vector<CooContribution> contributions{
{0U, 0U, 1.0, 2U, 0U},
{0U, 0U, -1.0e16, 1U, 0U},
{0U, 0U, 1.0e16, 0U, 0U}};
const SparsePattern pattern{{0U, 1U}, {0U}};
const std::vector<CooContribution> contributions{{0U, 0U, 1.0, 2U, 0U},
{0U, 0U, -1.0e16, 1U, 0U},
{0U, 0U, 1.0e16, 0U, 0U}};
auto first = SparseMatrix::fromCoo(1U, 1U, contributions, pattern);
ASSERT_TRUE(first.hasValue());
ASSERT_EQ(first.value().values().size(), 1U);
EXPECT_DOUBLE_EQ(first.value().values()[0U], 1.0);
auto first = SparseMatrix::FromCoo(1U, 1U, contributions, pattern);
ASSERT_TRUE(first.HasValue());
ASSERT_EQ(first.Value().Values().size(), 1U);
EXPECT_DOUBLE_EQ(first.Value().Values()[0U], 1.0);
auto reversedContributions = contributions;
std::reverse(reversedContributions.begin(), reversedContributions.end());
auto second = SparseMatrix::fromCoo(
1U, 1U, std::move(reversedContributions), pattern);
ASSERT_TRUE(second.hasValue());
EXPECT_EQ(second.value().rowOffsets(), first.value().rowOffsets());
EXPECT_EQ(second.value().columnIndices(), first.value().columnIndices());
EXPECT_EQ(second.value().values(), first.value().values());
auto reversed_contributions = contributions;
std::reverse(reversed_contributions.begin(), reversed_contributions.end());
auto second =
SparseMatrix::FromCoo(1U, 1U, std::move(reversed_contributions), pattern);
ASSERT_TRUE(second.HasValue());
EXPECT_EQ(second.Value().RowOffsets(), first.Value().RowOffsets());
EXPECT_EQ(second.Value().ColumnIndices(), first.Value().ColumnIndices());
EXPECT_EQ(second.Value().Values(), first.Value().Values());
}
TEST(SparseAssembly, RejectsInvalidIndexPatternAndShape) {
const SparsePattern oneEntry{{0U, 1U}, {0U}};
const auto expectFailure = [](
std::size_t rows,
std::size_t columns,
std::vector<CooContribution> contributions,
const SparsePattern& pattern) {
auto result = SparseMatrix::fromCoo(
rows, columns, std::move(contributions), pattern);
EXPECT_FALSE(result.hasValue());
if (!result.hasValue()) {
EXPECT_FALSE(result.status().isOk());
EXPECT_EQ(result.status().failureCategory(), fesa::FailureCategory::model);
EXPECT_FALSE(result.status().diagnostics().empty());
}
};
const SparsePattern one_entry{{0U, 1U}, {0U}};
const auto expect_failure = [](std::size_t rows, std::size_t columns,
std::vector<CooContribution> contributions,
const SparsePattern& pattern) {
auto result =
SparseMatrix::FromCoo(rows, columns, std::move(contributions), pattern);
EXPECT_FALSE(result.HasValue());
if (!result.HasValue()) {
EXPECT_FALSE(result.GetStatus().IsOk());
EXPECT_EQ(result.GetStatus().Category(), fesa::FailureCategory::kModel);
EXPECT_FALSE(result.GetStatus().Diagnostics().empty());
}
};
expectFailure(2U, 2U, {}, {{0U, 0U}, {}});
expectFailure(1U, 1U, {}, {{1U, 1U}, {0U}});
expectFailure(2U, 2U, {}, {{0U, 1U, 0U}, {0U}});
expectFailure(1U, 2U, {}, {{0U, 2U}, {1U, 0U}});
expectFailure(1U, 1U, {}, {{0U, 2U}, {0U, 0U}});
expectFailure(1U, 1U, {}, {{0U, 1U}, {1U}});
expectFailure(1U, 1U, {{1U, 0U, 1.0, 0U, 0U}}, oneEntry);
expectFailure(1U, 1U, {{0U, 1U, 1.0, 0U, 0U}}, oneEntry);
expectFailure(1U, 2U, {{0U, 1U, 1.0, 0U, 0U}}, {{0U, 1U}, {0U}});
expectFailure(
1U,
1U,
{{0U, 0U, (std::numeric_limits<double>::infinity)(), 0U, 0U}},
oneEntry);
expectFailure(
1U,
1U,
{{0U, 0U, (std::numeric_limits<double>::quiet_NaN)(), 0U, 0U}},
oneEntry);
expectFailure(
1U,
1U,
{{0U, 0U, (std::numeric_limits<double>::max)(), 0U, 0U},
{0U, 0U, (std::numeric_limits<double>::max)(), 1U, 0U}},
oneEntry);
expect_failure(2U, 2U, {}, {{0U, 0U}, {}});
expect_failure(1U, 1U, {}, {{1U, 1U}, {0U}});
expect_failure(2U, 2U, {}, {{0U, 1U, 0U}, {0U}});
expect_failure(1U, 2U, {}, {{0U, 2U}, {1U, 0U}});
expect_failure(1U, 1U, {}, {{0U, 2U}, {0U, 0U}});
expect_failure(1U, 1U, {}, {{0U, 1U}, {1U}});
expect_failure(1U, 1U, {{1U, 0U, 1.0, 0U, 0U}}, one_entry);
expect_failure(1U, 1U, {{0U, 1U, 1.0, 0U, 0U}}, one_entry);
expect_failure(1U, 2U, {{0U, 1U, 1.0, 0U, 0U}}, {{0U, 1U}, {0U}});
expect_failure(1U, 1U,
{{0U, 0U, (std::numeric_limits<double>::infinity)(), 0U, 0U}},
one_entry);
expect_failure(1U, 1U,
{{0U, 0U, (std::numeric_limits<double>::quiet_NaN)(), 0U, 0U}},
one_entry);
expect_failure(1U, 1U,
{{0U, 0U, (std::numeric_limits<double>::max)(), 0U, 0U},
{0U, 0U, (std::numeric_limits<double>::max)(), 1U, 0U}},
one_entry);
}
TEST(SparseAssembly, PreservesExpectedStructuralZeros) {
const SparsePattern pattern{
{0U, 2U, 4U, 5U},
{0U, 2U, 1U, 2U, 0U}};
std::vector<CooContribution> contributions{
{0U, 0U, 2.0, 0U, 0U},
{1U, 1U, 4.0, 0U, 1U},
{1U, 1U, -4.0, 1U, 0U}};
const SparsePattern pattern{{0U, 2U, 4U, 5U}, {0U, 2U, 1U, 2U, 0U}};
std::vector<CooContribution> contributions{
{0U, 0U, 2.0, 0U, 0U}, {1U, 1U, 4.0, 0U, 1U}, {1U, 1U, -4.0, 1U, 0U}};
auto result = SparseMatrix::fromCoo(
3U, 3U, std::move(contributions), pattern);
ASSERT_TRUE(result.hasValue());
EXPECT_EQ(result.value().rowOffsets(), pattern.rowOffsets);
EXPECT_EQ(result.value().columnIndices(), pattern.columnIndices);
EXPECT_EQ(
result.value().values(),
(std::vector<double>{2.0, 0.0, 0.0, 0.0, 0.0}));
EXPECT_EQ(
std::count(result.value().values().begin(), result.value().values().end(), 0.0),
4);
auto result =
SparseMatrix::FromCoo(3U, 3U, std::move(contributions), pattern);
ASSERT_TRUE(result.HasValue());
EXPECT_EQ(result.Value().RowOffsets(), pattern.rowOffsets);
EXPECT_EQ(result.Value().ColumnIndices(), pattern.columnIndices);
EXPECT_EQ(result.Value().Values(),
(std::vector<double>{2.0, 0.0, 0.0, 0.0, 0.0}));
EXPECT_EQ(std::count(result.Value().Values().begin(),
result.Value().Values().end(), 0.0),
4);
}
} // namespace
} // namespace
tests/unit/math/vector_test.cpp
+64 -63
View File
@@ -1,4 +1,4 @@
#include "fesa/math/vector.hpp"
#include "fesa/math/vector.h"
#include <gtest/gtest.h>
@@ -10,77 +10,78 @@ 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 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;
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& constOriginal = original;
EXPECT_EQ(constOriginal.data() + 2, &constOriginal[2]);
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 copied{original};
EXPECT_NE(copied.Data(), original.Data());
copied[0] = 99.0;
EXPECT_DOUBLE_EQ(original[0], 1.0);
Vector copyAssigned{0};
copyAssigned = original;
EXPECT_NE(copyAssigned.data(), original.data());
copyAssigned[1] = 17.0;
EXPECT_DOUBLE_EQ(original[1], -2.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 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 moveAssigned{1, -1.0};
moveAssigned = std::move(copyAssigned);
EXPECT_EQ(copyAssigned.size(), 0U);
EXPECT_EQ(moveAssigned.size(), 3U);
EXPECT_DOUBLE_EQ(moveAssigned[1], 17.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 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 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);
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>(constOriginal[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);
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);
}
} // namespace
} // namespace fesa
} // namespace
} // namespace fesa