baram2584/FESADev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c1d5cc3c0d9f1b884e9d0992e7a1ab2792d7d251
FESADev/tests/unit/solvers/eigen/mkl_feast_eigen_solver_test.cpp
T

632 lines
25 KiB
C++
Raw Blame History

#include "fesa/solvers/eigen/mkl_feast_eigen_solver.h"
#include <gtest/gtest.h>
#include <mkl.h>
#include <cmath>
#include <cstddef>
#include <limits>
#include <new>
#include <string>
#include <utility>
#include <vector>
#include "fesa/fem/dof_manager.h"
#include "fesa/math/sparse_matrix.h"
#include "solvers/eigen/mkl_feast_eigen_solver_test_seam.h"
namespace {
fesa::SparseMatrix MakeDenseCsr(const std::size_t size,
const std::vector<double>& values) {
EXPECT_EQ(values.size(), size * size);
fesa::SparsePattern pattern;
std::vector<fesa::CooContribution> contributions;
pattern.row_offsets.push_back(0U);
for (std::size_t row = 0U; row < size; ++row) {
for (std::size_t column = 0U; column < size; ++column) {
pattern.column_indices.push_back(column);
contributions.push_back(
{row, column, values[row * size + column], row, column});
}
pattern.row_offsets.push_back(pattern.column_indices.size());
}
auto matrix = fesa::SparseMatrix::FromCoo(size, size,
std::move(contributions), pattern);
EXPECT_TRUE(matrix.HasValue());
return std::move(matrix.Value());
}
void ExpectUnitGram(const fesa::Matrix& vectors) {
for (std::size_t left = 0U; left < vectors.Columns(); ++left) {
for (std::size_t right = 0U; right < vectors.Columns(); ++right) {
double dot = 0.0;
for (std::size_t row = 0U; row < vectors.Rows(); ++row) {
dot += vectors(row, left) * vectors(row, right);
}
EXPECT_NEAR(dot, left == right ? 1.0 : 0.0, 1.0e-10);
}
}
}
void RequireSuccess(const fesa::Result<fesa::FeastEigenResult>& result) {
if (result.HasValue()) return;
const auto& diagnostics = result.GetStatus().Diagnostics();
ASSERT_FALSE(diagnostics.empty());
ADD_FAILURE() << diagnostics.front().code << " "
<< diagnostics.front().entity_identity << " "
<< diagnostics.front().message;
}
void ExpectFailureCode(const fesa::Result<fesa::FeastEigenResult>& result,
const char* code) {
ASSERT_FALSE(result.HasValue());
ASSERT_FALSE(result.GetStatus().Diagnostics().empty());
EXPECT_EQ(result.GetStatus().Diagnostics().front().code, code);
}
void ExpectSameBackendCalls(const std::vector<fesa::FeastBackendCall>& first,
const std::vector<fesa::FeastBackendCall>& second) {
ASSERT_EQ(first.size(), second.size());
for (std::size_t index = 0U; index < first.size(); ++index) {
EXPECT_EQ(first[index].ordinal, second[index].ordinal);
EXPECT_EQ(first[index].kind, second[index].kind);
EXPECT_EQ(first[index].purpose, second[index].purpose);
EXPECT_DOUBLE_EQ(first[index].lower, second[index].lower);
EXPECT_DOUBLE_EQ(first[index].upper, second[index].upper);
EXPECT_EQ(first[index].allocated_m0, second[index].allocated_m0);
EXPECT_EQ(first[index].info, second[index].info);
EXPECT_EQ(first[index].count_available, second[index].count_available);
EXPECT_EQ(first[index].count, second[index].count);
EXPECT_EQ(first[index].outcome, second[index].outcome);
EXPECT_EQ(first[index].decision_reason, second[index].decision_reason);
}
}
void ExpectSameProjector(const fesa::Matrix& first, const fesa::Matrix& second,
const std::size_t columns) {
ASSERT_EQ(first.Rows(), second.Rows());
double squared_difference = 0.0;
for (std::size_t row = 0U; row < first.Rows(); ++row) {
for (std::size_t column = 0U; column < first.Rows(); ++column) {
double first_value = 0.0;
double second_value = 0.0;
for (std::size_t mode = 0U; mode < columns; ++mode) {
first_value += first(row, mode) * first(column, mode);
second_value += second(row, mode) * second(column, mode);
}
const double difference = first_value - second_value;
squared_difference += difference * difference;
}
}
EXPECT_LE(std::sqrt(squared_difference /
(2.0 * static_cast<double>(columns))),
1.0e-6);
}
void ExpectThreadSettingRestored(
const fesa::Result<fesa::FeastEigenResult>& result, const char* code) {
ExpectFailureCode(result, code);
const int restored = mkl_set_num_threads_local(2);
EXPECT_EQ(restored, 2);
}
} // namespace
TEST(MklFeastEigenSolver, SolvesN1AndRetainsBackendEvidence) {
const auto matrix = MakeDenseCsr(1U, {4.0});
fesa::MklFeastEigenSolver solver;
const auto result = solver.Solve(matrix, 1U, 1.0);
RequireSuccess(result);
if (!result.HasValue()) return;
EXPECT_EQ(result.Value().requested_modes, 1U);
ASSERT_EQ(result.Value().eigenvalues.size(), 1U);
EXPECT_NEAR(result.Value().eigenvalues[0U], 4.0, 1.0e-10);
EXPECT_DOUBLE_EQ(result.Value().operator_scale, 4.0);
EXPECT_EQ(result.Value().eigenvectors.Rows(), 1U);
EXPECT_EQ(result.Value().eigenvectors.Columns(), 1U);
EXPECT_EQ(result.Value().thread_count, 1U);
ASSERT_EQ(result.Value().base_fpm.size(), 128U);
EXPECT_EQ(result.Value().base_fpm[5U], 0);
ASSERT_FALSE(result.Value().backend_calls.empty());
EXPECT_EQ(result.Value().backend_calls.front().purpose, "total-enclosure");
EXPECT_EQ(result.Value().backend_calls.back().kind, "solve");
EXPECT_TRUE(result.Value().backend_calls.back().count_available);
EXPECT_EQ(result.Value().backend_calls.back().count,
result.Value().eigenvalues.size());
EXPECT_TRUE(result.Value().backend_calls.back().loop_available);
EXPECT_TRUE(result.Value().backend_calls.back().epsout_available);
EXPECT_EQ(result.Value().backend_calls.back().outcome, "accepted");
EXPECT_EQ(result.Value().backend_calls.back().decision_reason, "accepted");
EXPECT_FALSE(result.Value().upper_search_termination.empty());
ExpectUnitGram(result.Value().eigenvectors);
}
TEST(MklFeastEigenSolver, SolvesAllZeroWithExplicitPhysicalScale) {
const auto matrix = MakeDenseCsr(2U, {0.0, 0.0, 0.0, 0.0});
fesa::MklFeastEigenSolver solver;
const auto result = solver.Solve(matrix, 2U, 7.0);
RequireSuccess(result);
if (!result.HasValue()) return;
ASSERT_EQ(result.Value().eigenvalues.size(), 2U);
EXPECT_DOUBLE_EQ(result.Value().operator_scale, 7.0);
EXPECT_DOUBLE_EQ(result.Value().eigenvalues[0U], 0.0);
EXPECT_DOUBLE_EQ(result.Value().eigenvalues[1U], 0.0);
ExpectUnitGram(result.Value().eigenvectors);
}
TEST(MklFeastEigenSolver, PreservesRepeatedMultiplicityAndStableOrder) {
const auto matrix =
MakeDenseCsr(3U, {2.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 5.0});
fesa::MklFeastEigenSolver solver;
const auto first = solver.Solve(matrix, 3U, 1.0);
const auto second = solver.Solve(matrix, 3U, 1.0);
const auto third = solver.Solve(matrix, 3U, 1.0);
RequireSuccess(first);
RequireSuccess(second);
RequireSuccess(third);
if (!first.HasValue() || !second.HasValue() || !third.HasValue()) return;
ASSERT_EQ(first.Value().eigenvalues.size(), 3U);
EXPECT_NEAR(first.Value().eigenvalues[0U], 2.0, 1.0e-10);
EXPECT_NEAR(first.Value().eigenvalues[1U], 2.0, 1.0e-10);
EXPECT_NEAR(first.Value().eigenvalues[2U], 5.0, 1.0e-10);
EXPECT_EQ(first.Value().column_ids, second.Value().column_ids);
EXPECT_EQ(first.Value().column_ids, third.Value().column_ids);
EXPECT_EQ(first.Value().eigenvalues, second.Value().eigenvalues);
EXPECT_EQ(first.Value().eigenvalues, third.Value().eigenvalues);
ExpectSameBackendCalls(first.Value().backend_calls,
second.Value().backend_calls);
ExpectSameBackendCalls(first.Value().backend_calls,
third.Value().backend_calls);
ExpectSameProjector(first.Value().eigenvectors, second.Value().eigenvectors,
2U);
ExpectSameProjector(first.Value().eigenvectors, third.Value().eigenvectors,
2U);
ExpectUnitGram(first.Value().eigenvectors);
}
TEST(MklFeastEigenSolver, UsesGuardedPrefixWithoutDroppingRepeatedCluster) {
constexpr std::size_t kSize = 64U;
std::vector<double> values(kSize * kSize, 0.0);
for (std::size_t index = 0U; index < kSize; ++index) {
values[index * kSize + index] = index < 40U ? 1.0 : index - 38U;
}
const auto matrix = MakeDenseCsr(kSize, values);
fesa::MklFeastEigenSolver solver;
const auto one_mode = solver.Solve(matrix, 1U, 1.0);
const auto forty_first = solver.Solve(matrix, 41U, 1.0);
RequireSuccess(one_mode);
RequireSuccess(forty_first);
if (!one_mode.HasValue() || !forty_first.HasValue()) return;
EXPECT_GE(one_mode.Value().eigenvalues.size(), 40U);
EXPECT_GE(forty_first.Value().eigenvalues.size(), 41U);
for (std::size_t index = 0U; index < 40U; ++index) {
EXPECT_NEAR(one_mode.Value().eigenvalues[index], 1.0, 1.0e-10);
}
EXPECT_NEAR(forty_first.Value().eigenvalues[40U], 2.0, 1.0e-10);
EXPECT_EQ(one_mode.Value().backend_calls.back().kind, "solve");
EXPECT_EQ(forty_first.Value().backend_calls.back().kind, "solve");
}
TEST(MklFeastEigenSolver, RejectsSignificantNegativeSpectrum) {
const auto matrix = MakeDenseCsr(1U, {-2.0});
fesa::MklFeastEigenSolver solver;
const auto result = solver.Solve(matrix, 1U, 1.0);
ASSERT_FALSE(result.HasValue());
EXPECT_EQ(result.GetStatus().Category(), fesa::FailureCategory::kSolver);
ASSERT_EQ(result.GetStatus().Diagnostics().size(), 1U);
EXPECT_EQ(result.GetStatus().Diagnostics()[0U].code,
"negative-eigenvalue-spectrum");
}
TEST(MklFeastEigenSolver, KeepsCloseDistinctModesSeparated) {
const auto matrix = MakeDenseCsr(2U, {1.0, 0.0, 0.0, 1.001});
fesa::MklFeastEigenSolver solver;
const auto result = solver.Solve(matrix, 2U, 1.0);
RequireSuccess(result);
if (!result.HasValue()) return;
ASSERT_EQ(result.Value().eigenvalues.size(), 2U);
EXPECT_NEAR(result.Value().eigenvalues[0U], 1.0, 1.0e-10);
EXPECT_NEAR(result.Value().eigenvalues[1U], 1.001, 1.0e-10);
EXPECT_NEAR(std::abs(result.Value().eigenvectors(0U, 0U)), 1.0, 1.0e-10);
EXPECT_NEAR(std::abs(result.Value().eigenvectors(1U, 1U)), 1.0, 1.0e-10);
}
TEST(MklFeastEigenSolver, RestoresCallingThreadLocalSetting) {
const auto matrix = MakeDenseCsr(1U, {4.0});
const int prior = mkl_set_num_threads_local(2);
fesa::MklFeastEigenSolver solver;
const auto result = solver.Solve(matrix, 1U, 1.0);
const int restored = mkl_set_num_threads_local(2);
static_cast<void>(mkl_set_num_threads_local(prior));
RequireSuccess(result);
if (!result.HasValue()) return;
EXPECT_EQ(restored, 2);
}
TEST(MklFeastEigenSolver, RejectsInvalidRequestAndZeroScale) {
const auto matrix = MakeDenseCsr(1U, {0.0});
fesa::MklFeastEigenSolver solver;
const auto zero_request = solver.Solve(matrix, 0U, 1.0);
ASSERT_FALSE(zero_request.HasValue());
EXPECT_EQ(zero_request.GetStatus().Diagnostics()[0U].code,
"feast-invalid-dimension");
const auto invalid_scale = solver.Solve(matrix, 1U, 0.0);
ASSERT_FALSE(invalid_scale.HasValue());
EXPECT_EQ(invalid_scale.GetStatus().Diagnostics()[0U].code,
"feast-invalid-zero-scale");
}
TEST(MklFeastEigenSolver, PreservesLowestPrefixForZeroAndPositiveSpectra) {
const std::vector<std::vector<double>> spectra{{2.0},
{0.0, 0.0, 0.0, 2.0, 5.0, 9.0},
{1.0, 2.0, 4.0, 8.0},
{0.0, 0.0, 0.0, 0.0}};
const std::vector<std::vector<std::size_t>> requests{
{1U}, {1U, 4U, 6U}, {1U, 2U, 4U}, {1U, 4U}};
const fesa::MklFeastEigenSolver solver;
for (std::size_t case_index = 0U; case_index < spectra.size(); ++case_index) {
const auto& spectrum = spectra[case_index];
const auto n = spectrum.size();
std::vector<double> values(n * n, 0.0);
for (std::size_t i = 0U; i < n; ++i) values[i * n + i] = spectrum[i];
const auto matrix = MakeDenseCsr(n, values);
for (const auto requested : requests[case_index]) {
const auto result = solver.Solve(matrix, requested, 1.0);
RequireSuccess(result);
ASSERT_TRUE(result.HasValue());
ASSERT_GE(result.Value().eigenvalues.size(), requested);
for (std::size_t i = 0U; i < requested; ++i)
EXPECT_NEAR(result.Value().eigenvalues[i], spectrum[i], 1e-10);
ExpectUnitGram(result.Value().eigenvectors);
}
}
}
TEST(MklFeastEigenSolver, ResolvesCloseDistinctSpectrumAfterGivensCongruence) {
const std::array<double, 4> spectrum{1.0, 1.0 + std::ldexp(1.0, -28),
1.0 + std::ldexp(1.0, -27), 8.0};
const std::array<std::array<double, 4>, 4> q{{{{0.6, 0.0, 0.0, -0.8}},
{{0.0, 0.6, -0.8, 0.0}},
{{0.0, 0.8, 0.6, 0.0}},
{{0.8, 0.0, 0.0, 0.6}}}};
std::vector<double> values(16U, 0.0);
for (std::size_t i = 0U; i < 4U; ++i)
for (std::size_t j = 0U; j < 4U; ++j)
for (std::size_t k = 0U; k < 4U; ++k)
values[4U * i + j] += q[i][k] * spectrum[k] * q[j][k];
const auto result =
fesa::MklFeastEigenSolver{}.Solve(MakeDenseCsr(4U, values), 2U, 1.0);
RequireSuccess(result);
ASSERT_TRUE(result.HasValue());
ASSERT_EQ(result.Value().eigenvalues.size(), 4U);
for (std::size_t i = 0U; i < 4U; ++i)
EXPECT_NEAR(result.Value().eigenvalues[i], spectrum[i], 1e-12);
EXPECT_GT(result.Value().eigenvalues[1U] - result.Value().eigenvalues[0U],
1e-9);
ExpectUnitGram(result.Value().eigenvectors);
}
TEST(MklFeastEigenSolver, RejectsFatalCountStatusWithoutRetry) {
std::size_t hook_calls = 0U;
fesa::internal::ScopedFeastBackendTestHook hook(
[&](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
++hook_calls;
if (call.count && call.ordinal == 0U) outputs.info = -1;
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(1U, {2.0}), 1U, 1.0);
ExpectFailureCode(result, "eigen-feast-failed");
EXPECT_EQ(hook_calls, 1U);
}
TEST(MklFeastEigenSolver, BoundsCountCallsAndUpperSearchReservations) {
constexpr std::size_t kMaximum = (std::numeric_limits<std::size_t>::max)();
EXPECT_TRUE(fesa::internal::CanCallFeast(511U));
EXPECT_FALSE(fesa::internal::CanCallFeast(512U));
EXPECT_FALSE(fesa::internal::CanCallFeast(kMaximum));
EXPECT_TRUE(fesa::internal::CanStartUpperCandidate(363U));
EXPECT_FALSE(fesa::internal::CanStartUpperCandidate(364U));
EXPECT_FALSE(fesa::internal::CanStartUpperCandidate(kMaximum));
}
TEST(MklFeastEigenSolver, BoundsPrivateWorkspaceProductsBeforeAllocation) {
constexpr std::size_t kMaximum = (std::numeric_limits<std::size_t>::max)();
EXPECT_TRUE(fesa::internal::ProductFits(0U, kMaximum));
EXPECT_TRUE(fesa::internal::ProductFits(1U, kMaximum));
EXPECT_FALSE(fesa::internal::ProductFits(kMaximum, 2U));
const std::size_t byte_limit = static_cast<std::size_t>(
(std::numeric_limits<std::ptrdiff_t>::max)() / sizeof(double));
const std::size_t storage_limit =
(std::min)(byte_limit, std::vector<double>{}.max_size());
EXPECT_TRUE(fesa::internal::FitsDoubleStorage(0U));
EXPECT_TRUE(fesa::internal::FitsDoubleStorage(storage_limit));
EXPECT_FALSE(fesa::internal::FitsDoubleStorage(kMaximum));
if (storage_limit < kMaximum)
EXPECT_FALSE(fesa::internal::FitsDoubleStorage(storage_limit + 1U));
}
TEST(MklFeastEigenSolver, TranslatesCountWorkspaceAllocationFailure) {
const int prior = mkl_set_num_threads_local(2);
fesa::internal::ScopedFeastWorkspaceTestHook hook([](const bool count) {
if (count) throw std::bad_alloc();
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(1U, {2.0}), 1U, 1.0);
ExpectThreadSettingRestored(result, "eigen-allocation-failed");
static_cast<void>(mkl_set_num_threads_local(prior));
}
TEST(MklFeastEigenSolver, TranslatesSolveWorkspaceAllocationFailure) {
const int prior = mkl_set_num_threads_local(2);
fesa::internal::ScopedFeastWorkspaceTestHook hook([](const bool count) {
if (!count) throw std::bad_alloc();
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(1U, {2.0}), 1U, 1.0);
ExpectThreadSettingRestored(result, "eigen-allocation-failed");
static_cast<void>(mkl_set_num_threads_local(prior));
}
TEST(MklFeastEigenSolver, StopsInitialInfoOneAfterThreeCountCalls) {
std::size_t count_calls = 0U;
fesa::internal::ScopedFeastBackendTestHook hook(
[&](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
if (call.count) {
++count_calls;
outputs.info = 1;
}
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(1U, {2.0}), 1U, 1.0);
ExpectFailureCode(result, "eigen-feast-failed");
EXPECT_EQ(count_calls, 3U);
}
TEST(MklFeastEigenSolver, RejectsFinalCountHistoryMismatch) {
fesa::internal::ScopedFeastBackendTestHook hook(
[](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
// n=1 has total enclosure at ordinal 0 and final count at ordinal 1.
if (call.count && call.ordinal == 1U) outputs.m0 = 0;
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(1U, {2.0}), 1U, 1.0);
ExpectFailureCode(result, "eigen-count-inconsistent");
}
TEST(MklFeastEigenSolver, RejectsDecreasingCountAcrossDistinctUpperGuards) {
constexpr std::size_t kSize = 11U;
std::vector<double> values(kSize * kSize, 0.0);
for (std::size_t index = 0U; index < kSize; ++index)
values[index * kSize + index] = static_cast<double>(index + 1U);
fesa::internal::ScopedFeastBackendTestHook hook(
[kSize](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
// Ordinals 1 and 2 are the first candidate's increasing upper guards.
if (call.count && call.ordinal == 1U) outputs.m0 = kSize;
if (call.count && call.ordinal == 2U) outputs.m0 = kSize - 1U;
});
const auto result =
fesa::MklFeastEigenSolver{}.Solve(MakeDenseCsr(kSize, values), 1U, 1.0);
ExpectFailureCode(result, "eigen-count-inconsistent");
}
TEST(MklFeastEigenSolver, PreservesRawNegativeBoundaryAndRejectsBelowIt) {
const double threshold = -1.0e-9;
const std::vector<double> accepted_negatives{
-1.0e-12, threshold};
for (const double negative : accepted_negatives) {
fesa::internal::ScopedFeastBackendTestHook hook(
[negative](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
if (!call.count) {
ASSERT_EQ(outputs.eigenvalues.size(), 3U);
outputs.eigenvalues = {negative, 0.0, 1.0};
}
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(3U, {negative, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
1.0}),
3U, 1.0);
RequireSuccess(result);
if (!result.HasValue()) continue;
ASSERT_EQ(result.Value().eigenvalues.size(), 3U);
EXPECT_DOUBLE_EQ(result.Value().eigenvalues[0U], negative);
EXPECT_DOUBLE_EQ(result.Value().eigenvalues[1U], 0.0);
EXPECT_DOUBLE_EQ(result.Value().eigenvalues[2U], 1.0);
}
const double below_threshold =
std::nextafter(threshold, -(std::numeric_limits<double>::infinity)());
fesa::internal::ScopedFeastBackendTestHook hook(
[below_threshold](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
if (!call.count) outputs.eigenvalues = {below_threshold, 0.0, 1.0};
});
const auto rejected = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(3U, {below_threshold, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
1.0}),
3U, 1.0);
ExpectFailureCode(rejected, "negative-eigenvalue-spectrum");
}
TEST(MklFeastEigenSolver, DoesNotRepeatUnchangedSolveAfterReturnedMismatch) {
std::size_t solve_calls = 0U;
fesa::internal::ScopedFeastBackendTestHook hook(
[&](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
if (!call.count) {
++solve_calls;
outputs.returned = 0;
}
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(1U, {2.0}), 1U, 1.0);
ExpectFailureCode(result, "eigen-feast-failed");
EXPECT_EQ(solve_calls, 1U);
}
TEST(MklFeastEigenSolver, RetriesSolveInfoTwoOnlyWithLargerInterval) {
constexpr std::size_t kSize = 11U;
std::vector<double> values(kSize * kSize, 0.0);
for (std::size_t index = 0U; index < kSize; ++index)
values[index * kSize + index] = static_cast<double>(index + 1U);
std::vector<double> solve_uppers;
fesa::internal::ScopedFeastBackendTestHook hook(
[&](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
if (!call.count) {
solve_uppers.push_back(call.upper);
if (solve_uppers.size() == 1U) outputs.info = 2;
}
});
const auto result =
fesa::MklFeastEigenSolver{}.Solve(MakeDenseCsr(kSize, values), 1U, 1.0);
RequireSuccess(result);
if (!result.HasValue()) return;
ASSERT_EQ(solve_uppers.size(), 2U);
EXPECT_LT(solve_uppers[0U], solve_uppers[1U]);
}
TEST(MklFeastEigenSolver, RejectsNonfiniteSolveOutputWithoutRetry) {
std::size_t solve_calls = 0U;
fesa::internal::ScopedFeastBackendTestHook hook(
[&](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
if (!call.count) {
++solve_calls;
outputs.eigenvalues[0U] =
(std::numeric_limits<double>::quiet_NaN)();
}
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(1U, {2.0}), 1U, 1.0);
ExpectFailureCode(result, "invalid-eigenvalue-result");
EXPECT_EQ(solve_calls, 1U);
}
TEST(MklFeastEigenSolver, RejectsResidualFailureWithoutSolveRetry) {
std::size_t solve_calls = 0U;
fesa::internal::ScopedFeastBackendTestHook hook(
[&](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
if (!call.count) {
++solve_calls;
// N=1 still requires validation of the returned all-c=2 modes.
outputs.vectors[2U] = std::sqrt(0.5);
outputs.vectors[3U] = std::sqrt(0.5);
}
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(2U, {1.0, 0.0, 0.0, 2.0}), 1U, 1.0);
ExpectFailureCode(result, "eigenpair-validation-failed");
EXPECT_NE(result.GetStatus().Diagnostics().front().message.find(
"Independent whitened residual exceeds"),
std::string::npos);
EXPECT_EQ(solve_calls, 1U);
}
TEST(MklFeastEigenSolver, RejectsNonfiniteVectorAndEpsoutWithoutRetry) {
for (const bool nonfinite_vector : {true, false}) {
std::size_t solve_calls = 0U;
fesa::internal::ScopedFeastBackendTestHook hook(
[&](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
if (!call.count) {
++solve_calls;
if (nonfinite_vector)
outputs.vectors[0U] =
(std::numeric_limits<double>::quiet_NaN)();
else
outputs.epsout = (std::numeric_limits<double>::quiet_NaN)();
}
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(1U, {2.0}), 1U, 1.0);
ExpectFailureCode(result, "invalid-eigenvalue-result");
EXPECT_EQ(solve_calls, 1U);
}
}
TEST(MklFeastEigenSolver, RejectsGramFailureWithoutSolveRetry) {
std::size_t solve_calls = 0U;
fesa::internal::ScopedFeastBackendTestHook hook(
[&](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
if (!call.count) {
++solve_calls;
ASSERT_EQ(outputs.vectors.size(), 4U);
outputs.vectors = {1.0, 0.0, 1.0, 0.0};
}
});
const auto result = fesa::MklFeastEigenSolver{}.Solve(
MakeDenseCsr(2U, {0.0, 0.0, 0.0, 0.0}), 2U, 1.0);
ExpectFailureCode(result, "eigenpair-validation-failed");
EXPECT_EQ(solve_calls, 1U);
}
TEST(MklFeastEigenSolver, UsesCertifiedEnclosureAfterOptionalInfoOne) {
constexpr std::size_t kSize = 11U;
std::vector<double> values(kSize * kSize, 0.0);
for (std::size_t index = 0U; index < kSize; ++index)
values[index * kSize + index] = static_cast<double>(index + 1U);
fesa::internal::ScopedFeastBackendTestHook hook(
[](const fesa::internal::FeastBackendTestCall& call,
fesa::internal::FeastBackendTestOutputs& outputs) {
// The first upper guard follows the total enclosing count.
if (call.count && call.ordinal == 1U) outputs.info = 1;
});
const auto result =
fesa::MklFeastEigenSolver{}.Solve(MakeDenseCsr(kSize, values), 1U, 1.0);
RequireSuccess(result);
if (!result.HasValue()) return;
EXPECT_EQ(result.Value().upper_search_termination, "optional-status");
ASSERT_GE(result.Value().backend_calls.size(), 2U);
EXPECT_EQ(result.Value().backend_calls[1U].outcome, "optional-abandoned");
}
Reference in New Issue View Git Blame Copy Permalink