perf(math): route ordinary products through MKL and preserve arithmetic

tests/unit/math/sparse_matrix_test.cpp

@@ -3,6 +3,8 @@
 #include <gtest/gtest.h>
 
 #include <algorithm>
+#include <cmath>
+#include <future>
 #include <limits>
 #include <type_traits>
 #include <utility>
@@ -131,4 +133,101 @@ TEST(SparseAssembly, PreservesExpectedStructuralZeros) {
             4);
 }
 
+TEST(SparseAssembly, MultipliesRectangularCopyMoveAndConcurrentConstCalls) {
+  auto assembled = SparseMatrix::FromCoo(
+      3U, 5U, {{0U, 4U, 3.0, 0U, 0U}, {2U, 1U, -2.0, 1U, 0U}},
+      {{0U, 1U, 1U, 2U}, {4U, 1U}});
+  ASSERT_TRUE(assembled.HasValue());
+  const auto original = assembled.Value();
+  auto copied = original;
+  auto moved = std::move(copied);
+  Vector rhs{5U, 2.0};
+  const auto evaluate = [&rhs](const SparseMatrix& matrix) {
+    for (int repeat = 0; repeat < 20; ++repeat) {
+      const auto product = matrix.Multiply(rhs);
+      if (product.Size() != 3U || product[0U] != 6.0 ||
+          product[1U] != 0.0 || product[2U] != -4.0) return false;
+    }
+    return true;
+  };
+  auto first = std::async(std::launch::async, [&] { return evaluate(moved); });
+  auto second = std::async(std::launch::async, [&] { return evaluate(moved); });
+  EXPECT_TRUE(first.get());
+  EXPECT_TRUE(second.get());
+  EXPECT_TRUE(evaluate(original));
+  auto replacement = SparseMatrix::FromCoo(
+      1U, 1U, {{0U, 0U, 7.0, 0U, 0U}}, {{0U, 1U}, {0U}});
+  ASSERT_TRUE(replacement.HasValue());
+  moved = replacement.Value();
+  EXPECT_DOUBLE_EQ(moved.Multiply(Vector{1U, 3.0})[0U], 21.0);
+  EXPECT_TRUE(evaluate(original));
+}
+
+TEST(SparseAssembly, PreservesZeroShapesAndEmptyRows) {
+  auto no_rows = SparseMatrix::FromCoo(0U, 3U, {}, {{0U}, {}});
+  auto no_columns = SparseMatrix::FromCoo(2U, 0U, {}, {{0U, 0U, 0U}, {}});
+  auto no_entries = SparseMatrix::FromCoo(2U, 3U, {}, {{0U, 0U, 0U}, {}});
+  ASSERT_TRUE(no_rows.HasValue());
+  ASSERT_TRUE(no_columns.HasValue());
+  ASSERT_TRUE(no_entries.HasValue());
+  EXPECT_EQ(no_rows.Value().Multiply(Vector{3U}).Size(), 0U);
+  const auto empty_columns = no_columns.Value().Multiply(Vector{0U});
+  const auto empty_entries = no_entries.Value().Multiply(Vector{3U});
+  ASSERT_EQ(empty_columns.Size(), 2U);
+  ASSERT_EQ(empty_entries.Size(), 2U);
+  for (std::size_t row = 0; row < 2U; ++row) {
+    EXPECT_DOUBLE_EQ(empty_columns[row], 0.0);
+    EXPECT_DOUBLE_EQ(empty_entries[row], 0.0);
+  }
+}
+
+TEST(SparseAssembly, KeepsIeeeNonfiniteResultsAndRecoversAfterBadRhs) {
+  auto matrix = SparseMatrix::FromCoo(
+      2U, 2U, {{0U, 0U, 2.0, 0U, 0U}}, {{0U, 1U, 2U}, {0U, 1U}});
+  ASSERT_TRUE(matrix.HasValue());
+  Vector rhs{2U, (std::numeric_limits<double>::infinity)()};
+  const auto nonfinite = matrix.Value().Multiply(rhs);
+  EXPECT_TRUE(std::isinf(nonfinite[0U]));
+  EXPECT_TRUE(std::isnan(nonfinite[1U]));  // Stored structural zero times Inf.
+  rhs[0U] = (std::numeric_limits<double>::max)();
+  EXPECT_TRUE(std::isinf(matrix.Value().Multiply(rhs)[0U]));
+  EXPECT_THROW(static_cast<void>(matrix.Value().Multiply(Vector{1U})),
+               std::invalid_argument);
+  rhs[0U] = 3.0;
+  rhs[1U] = 4.0;
+  const auto finite = matrix.Value().Multiply(rhs);
+  EXPECT_DOUBLE_EQ(finite[0U], 6.0);
+  EXPECT_DOUBLE_EQ(finite[1U], 0.0);
+}
+
+TEST(SparseAssembly, MatchesIndependentLongDoubleResidualOnUnevenRows) {
+  const std::vector<double> entries{1.25, -0.375, 4.5, -3.0, 0.125, 2.0};
+  const SparsePattern pattern{{0U, 3U, 3U, 5U, 6U}, {0U, 2U, 4U, 1U, 3U, 2U}};
+  std::vector<CooContribution> contributions;
+  for (std::size_t row = 0; row < 4U; ++row) {
+    for (auto position = pattern.row_offsets[row];
+         position < pattern.row_offsets[row + 1U]; ++position) {
+      contributions.push_back(
+          {row, pattern.column_indices[position], entries[position], row,
+           position});
+    }
+  }
+  auto matrix = SparseMatrix::FromCoo(4U, 5U, contributions, pattern);
+  ASSERT_TRUE(matrix.HasValue());
+  Vector rhs{5U};
+  for (std::size_t column = 0; column < 5U; ++column) {
+    rhs[column] = 0.3 + static_cast<double>(column) * 0.7;
+  }
+  const auto product = matrix.Value().Multiply(rhs);
+  for (std::size_t row = 0; row < 4U; ++row) {
+    long double expected = 0;
+    for (auto position = pattern.row_offsets[row];
+         position < pattern.row_offsets[row + 1U]; ++position) {
+      expected += static_cast<long double>(entries[position]) *
+                  rhs[pattern.column_indices[position]];
+    }
+    EXPECT_NEAR(product[row], static_cast<double>(expected), 2.0e-14);
+  }
+}
+
 }  // namespace