test: preserve Dev verification contracts through Refactor APIs

tests/unit/math/high_low_arithmetic_test.cpp

@@ -1,10 +1,16 @@
 #include "../../../src/fesa/math/high_low_arithmetic.h"
-#include "elements/hex8_pair_simd.h"
 
 #include <gtest/gtest.h>
+#include "elements/hex8_pair_simd.h"
 
 #include <cmath>
+#include <cstdint>
+#include <cstring>
 #include <limits>
+#include <random>
+#include <vector>
+
+#include "high_low_arithmetic_original.h"
 
 namespace {
 using namespace fesa::math_internal;
@@ -126,9 +132,111 @@ TEST(HighLowArithmetic, RejectsChangedRoundingAndFlushToZeroEnvironment) {
   EXPECT_FALSE(ArithmeticEnvironmentSupported());
 #endif
 }
-}  // namespace
 
-namespace {
+std::uint64_t Bits(const double value) {
+  std::uint64_t result = 0;
+  std::memcpy(&result, &value, sizeof(result));
+  return result;
+}
+
+double FromBits(const std::uint64_t bits) {
+  double result = 0;
+  std::memcpy(&result, &bits, sizeof(result));
+  return result;
+}
+
+TEST(HighLowArithmetic, FiniteClassificationMatchesBinary64Boundaries) {
+  const auto check = [](const double value) {
+    const bool expected = std::isfinite(value);
+    EXPECT_EQ(IsFinite(HighLow{value, 0.0}), expected);
+    EXPECT_EQ(IsFinite(HighLow{1.0, value}), expected);
+  };
+  for (std::uint64_t exponent = 0; exponent < 2048U; ++exponent) {
+    for (const auto fraction : {0ULL, 1ULL, 1ULL << 51U,
+                                (1ULL << 52U) - 1ULL}) {
+      for (const auto sign : {0ULL, 1ULL << 63U})
+        check(FromBits(sign | (exponent << 52U) | fraction));
+    }
+  }
+  std::mt19937_64 random{0x5800f17U};
+  for (int sample = 0; sample < 10000; ++sample) check(FromBits(random()));
+}
+
+void ExpectSamePair(const HighLow actual,
+                    const fesa::high_low_original::HighLow expected) {
+  EXPECT_EQ(Bits(actual.high), Bits(expected.high));
+  EXPECT_EQ(Bits(actual.low), Bits(expected.low));
+}
+
+TEST(HighLowArithmetic, BitExponentMatchesFrozenOracleAcrossEveryExponent) {
+  ASSERT_TRUE(ArithmeticEnvironmentSupported());
+  // Every normal exponent, every possible trailing significand-bit count,
+  // both signs; then every subnormal single-bit and mixed-bit boundary.
+  for (std::uint64_t exponent = 1; exponent < 2047; ++exponent) {
+    for (unsigned trailing = 0; trailing <= 52U; ++trailing) {
+      const auto fraction = trailing == 52U ? 0ULL : 1ULL << trailing;
+      for (const auto sign : {0ULL, 1ULL << 63U}) {
+        const double value = FromBits(sign | (exponent << 52U) | fraction);
+        ASSERT_EQ(LowestBitExponent(value),
+                  fesa::high_low_original::LowestBitExponent(value));
+      }
+    }
+  }
+  for (unsigned bit = 0; bit < 52U; ++bit) {
+    for (const auto significand : {1ULL << bit, (1ULL << 52U) - (1ULL << bit)}) {
+      const double value = FromBits(significand);
+      EXPECT_EQ(LowestBitExponent(value),
+                fesa::high_low_original::LowestBitExponent(value));
+    }
+  }
+}
+
+TEST(HighLowArithmetic, OptimizedArithmeticMatchesFrozenOriginalBits) {
+  ASSERT_TRUE(ArithmeticEnvironmentSupported());
+  std::vector<double> values{0.0, -0.0,
+      std::numeric_limits<double>::denorm_min(),
+      -std::numeric_limits<double>::denorm_min(),
+      std::numeric_limits<double>::min(),
+      std::nextafter(std::numeric_limits<double>::min(), 0.0),
+      std::numeric_limits<double>::max(),
+      -std::numeric_limits<double>::max(), 1.0, -1.0,
+      std::nextafter(1.0, 2.0), std::ldexp(1.0, -53),
+      std::ldexp(1.0, -54), std::numeric_limits<double>::infinity(),
+      -std::numeric_limits<double>::infinity(),
+      std::numeric_limits<double>::quiet_NaN()};
+  std::mt19937_64 random{0x58a0fU};
+  for (int sample = 0; sample < 4000; ++sample) {
+    values.push_back(FromBits(random()));
+  }
+  for (std::size_t index = 0; index < values.size(); ++index) {
+    const double high = values[index];
+    const double low = values[(index * 13U + 7U) % values.size()];
+    const fesa::high_low_original::HighLow original{high, low};
+    EXPECT_EQ(IsNormalized({high, low}),
+              fesa::high_low_original::IsNormalized(original));
+    // Normalize a raw pair with the frozen operation, never the new predicate.
+    const auto a = fesa::high_low_original::TwoSum(high, low);
+    const auto b = fesa::high_low_original::TwoSum(
+        values[(index + 1U) % values.size()],
+        values[(index * 3U + 2U) % values.size()]);
+    ExpectSamePair(Add({a.high, a.low}, {b.high, b.low}),
+                   fesa::high_low_original::Add(a, b));
+    ExpectSamePair(Multiply({a.high, a.low}, {b.high, b.low}),
+                   fesa::high_low_original::Multiply(a, b));
+    ExpectSamePair(Divide({a.high, a.low}, {b.high, b.low}),
+                   fesa::high_low_original::Divide(a, b));
+    ExpectSamePair(TwoProduct(high, low),
+                   fesa::high_low_original::TwoProduct(high, low));
+  }
+  for (double high : {1.0, std::nextafter(1.0, 2.0), -1.0,
+                      std::numeric_limits<double>::max()}) {
+    for (double low : {0.0, -0.0, std::ldexp(1.0, -53),
+                       -std::ldexp(1.0, -53)}) {
+      EXPECT_EQ(IsNormalized({high, low}),
+                fesa::high_low_original::IsNormalized({high, low}));
+    }
+  }
+}
 TEST(HighLowArithmetic, PacketDispatchRetainsComponentsAndInstructionGates) {
   using namespace fesa::hex8_internal;
   const std::uint32_t leaf1 = (1U << 12) | (1U << 26) | (1U << 27) | (1U << 28);