FESADev/tests/unit/math/high_low_arithmetic_test.cpp

#include "../../../src/fesa/math/high_low_arithmetic.h"
#include "elements/hex8_pair_simd.h"

#include <gtest/gtest.h>

#include <cmath>
#include <limits>

namespace {
using namespace fesa::math_internal;

TEST(HighLowArithmetic, RetainsSubUlpAdditionsAndSignedCancellation) {
  ASSERT_TRUE(ArithmeticEnvironmentSupported());
  EXPECT_FALSE(IsNormalized(HighLow{-0.0, -0.0}));
  EXPECT_TRUE(IsNormalized(HighLow{-0.0}));
  EXPECT_FALSE(std::signbit(HighLow{-0.0}.high));
  EXPECT_FALSE(std::signbit(Negate(HighLow{}).high));
  EXPECT_FALSE(std::signbit(Negate(HighLow{}).low));
  const double tiny = std::ldexp(1.0, -60);
  const auto positive = Add(HighLow{1}, HighLow{tiny});
  EXPECT_EQ(positive.high, 1);
  EXPECT_EQ(positive.low, tiny);
  EXPECT_EQ(Rounded(positive), 1);
  const auto difference = Subtract(positive, HighLow{1});
  EXPECT_EQ(difference.high, tiny);
  EXPECT_EQ(difference.low, 0);
  EXPECT_EQ(Compare(positive, HighLow{1}), 1);
  EXPECT_EQ(Compare(HighLow{1, -tiny}, HighLow{1}), -1);
  EXPECT_EQ(Compare(Add(positive, Negate(positive)), HighLow{}), 0);
  EXPECT_EQ(Abs(HighLow{-1, -tiny}).low, tiny);
}

TEST(HighLowArithmetic, AllProductTermsAndDivisionResidualReachState) {
  const double tiny = std::ldexp(1.0, -60);
  const auto product = Multiply(HighLow{1, tiny}, HighLow{1, -tiny});
  EXPECT_EQ(product.high, 1);
  EXPECT_EQ(product.low, -std::ldexp(1.0, -120));
  const auto quotient = Divide(HighLow{1}, HighLow{3});
  ASSERT_TRUE(IsNormalized(quotient));
  const auto defect = Subtract(Multiply(quotient, HighLow{3}), HighLow{1});
  EXPECT_LE(std::abs(defect.high), std::ldexp(1.0, -104));
  const auto cancellation = Subtract(HighLow{1, tiny}, HighLow{1, tiny / 2});
  EXPECT_EQ(cancellation.high, tiny / 2);
  EXPECT_EQ(cancellation.low, 0);
}

TEST(HighLowArithmetic, NormalizesTiesAndCrossesPowerOfTwoBoundary) {
  const double half_ulp = std::ldexp(1.0, -53);
  EXPECT_TRUE(IsNormalized(HighLow{1, half_ulp}));
  EXPECT_FALSE(IsNormalized(HighLow{std::nextafter(1.0, 2.0), -half_ulp}));
  auto result = HighLow{1};
  for (int i = 0; i < 4; ++i) result = Add(result, HighLow{half_ulp / 2});
  EXPECT_EQ(result.high, std::nextafter(1.0, 2.0));
  EXPECT_EQ(result.low, 0);
  const auto minimum = HighLow{std::numeric_limits<double>::denorm_min()};
  EXPECT_EQ(Add(minimum, minimum).high, 2 * minimum.high);
  EXPECT_EQ(Multiply(minimum, HighLow{1}).high, minimum.high);
}

TEST(HighLowArithmetic, RejectsUnsupportedDyadicTailAndNonfiniteResults) {
  const auto minimum = HighLow{std::numeric_limits<double>::denorm_min()};
  EXPECT_FALSE(IsFinite(Multiply(minimum, HighLow{0.5})));
  EXPECT_FALSE(IsFinite(Multiply(HighLow{std::ldexp(1.0, -1022)},
                                HighLow{std::nextafter(0.5, 1.0)})));
  EXPECT_FALSE(IsFinite(Divide(minimum, HighLow{2})));
  EXPECT_FALSE(IsFinite(Divide(HighLow{1}, HighLow{})));
  EXPECT_FALSE(IsFinite(Add(HighLow{std::numeric_limits<double>::max()},
                           HighLow{std::numeric_limits<double>::max()})));
  EXPECT_EQ(Compare(InvalidHighLow(), HighLow{}), 2);
  EXPECT_FALSE(IsNormalized(HighLow{1, 1}));
  EXPECT_TRUE(std::isnan(Rounded(HighLow{1, 1})));
}

TEST(HighLowArithmetic, ExactDyadicOracleBoundsDiscardedTailAndRefinement) {
  // Expected pairs were obtained independently using exact rational arithmetic.
  // Add and multiply deliberately discard a term at 2^-108; neither is exact.
  for (int scale : {-100, 0, 100}) {
    const auto x = HighLow{std::ldexp(1.0, scale), std::ldexp(1.0, scale-54)};
    const auto y = HighLow{std::ldexp(1.0, scale-53), std::ldexp(1.0, scale-108)};
    const auto sum = Add(x, y);
    EXPECT_EQ(sum.high, std::ldexp(0x1.0000000000001p+0, scale));
    EXPECT_EQ(sum.low, -std::ldexp(1.0, scale-54));
    const auto square = Multiply(x, x);
    EXPECT_EQ(square.high, std::ldexp(1.0, 2*scale));
    EXPECT_EQ(square.low, std::ldexp(1.0, 2*scale-53));
  }
  const auto third = Divide(HighLow{1}, HighLow{3});
  EXPECT_EQ(third.high, 0x1.5555555555555p-2);
  EXPECT_EQ(third.low, 0x1.5555555555555p-56);
  const auto third_residual = Subtract(Multiply(HighLow{3}, third), HighLow{1});
  EXPECT_EQ(third_residual.high, -std::ldexp(1.0, -108));
  EXPECT_EQ(third_residual.low, 0);
  const auto refined = Divide(HighLow{1, std::ldexp(1.0,-60)},
                              HighLow{1.25, -std::ldexp(1.0,-60)});
  EXPECT_EQ(refined.high, 0x1.999999999999ap-1);
  EXPECT_EQ(refined.low, -0x1.8e147ae147ae1p-55);
  const auto boundary = TwoProduct(0x1.0000000000001p+0,
                                   0x1.0000000000001p-970);
  EXPECT_EQ(boundary.high, 0x1.0000000000002p-970);
  EXPECT_EQ(boundary.low, std::numeric_limits<double>::denorm_min());
  EXPECT_FALSE(IsFinite(TwoProduct(std::nextafter(1.0, 2.0),
      std::nextafter(std::numeric_limits<double>::min(), 1.0))));
}

TEST(HighLowArithmetic, RejectsChangedRoundingAndFlushToZeroEnvironment) {
  struct Restore {
    int rounding = std::fegetround();
#if defined(_M_X64) || defined(__SSE2__)
    unsigned csr = _mm_getcsr();
#endif
    ~Restore() {
      std::fesetround(rounding);
#if defined(_M_X64) || defined(__SSE2__)
      _mm_setcsr(csr);
#endif
    }
  } restore;
  ASSERT_TRUE(ArithmeticEnvironmentSupported());
  ASSERT_EQ(std::fesetround(FE_DOWNWARD), 0);
  EXPECT_FALSE(ArithmeticEnvironmentSupported());
  ASSERT_EQ(std::fesetround(FE_TONEAREST), 0);
#if defined(_M_X64) || defined(__SSE2__)
  _mm_setcsr(restore.csr | 0x8000U);
  EXPECT_FALSE(ArithmeticEnvironmentSupported());
  _mm_setcsr(restore.csr | 0x0040U);
  EXPECT_FALSE(ArithmeticEnvironmentSupported());
#endif
}
}  // namespace

namespace {
TEST(HighLowArithmetic, PacketDispatchRetainsComponentsAndInstructionGates) {
  using namespace fesa::hex8_internal;
  const std::uint32_t leaf1 = (1U << 12) | (1U << 26) | (1U << 27) | (1U << 28);
  const std::uint32_t leaf7 = (1U << 3) | (1U << 5) | (1U << 8);
  EXPECT_TRUE(SupportsMaterialPacketInstructions(leaf1, 6, leaf7));
  for (const auto bit : {12,26,27,28})
    EXPECT_FALSE(SupportsMaterialPacketInstructions(leaf1 & ~(1U << bit),6,leaf7));
  for (const auto bit : {3,5,8})
    EXPECT_FALSE(SupportsMaterialPacketInstructions(leaf1,6,leaf7 & ~(1U << bit)));
  EXPECT_FALSE(SupportsMaterialPacketInstructions(leaf1,2,leaf7));
  EXPECT_FALSE(SupportsMaterialPacketInstructions(leaf1,4,leaf7));
  const auto selected = SelectMaterialPacketEvaluator();
  std::size_t finite_pairs = 0, retained_low_pairs = 0, invalid_pairs = 0;
  RecordProperty("selected_backend", selected == EvaluateMaterialPacketAvx2 ? "avx2" : "scalar");
  const auto verify = [selected, &finite_pairs, &retained_low_pairs, &invalid_pairs](
                          const MaterialPacketInput& input) {
    PairPacket expected{}, actual{};
    EvaluateMaterialPacketScalar(input, &expected);
    selected(input, &actual);
    for (std::size_t lane = 0; lane < 4; ++lane) {
      if (std::isnan(expected.values[lane].high)) {
        ++invalid_pairs;
        EXPECT_TRUE(std::isnan(actual.values[lane].high));
      } else {
        ++finite_pairs;
        if (expected.values[lane].low != 0) ++retained_low_pairs;
        EXPECT_DOUBLE_EQ(actual.values[lane].high, expected.values[lane].high);
        EXPECT_DOUBLE_EQ(actual.values[lane].low, expected.values[lane].low);
        EXPECT_EQ(std::signbit(actual.values[lane].low),
                  std::signbit(expected.values[lane].low));
      }
    }
  };
  for (const bool full_low : {false,true})
  for (const int exponent : {-970,-100,0,100,400}) {
    MaterialPacketInput input{};
    input.weight = {0.5, 0};
    for (std::size_t lane = 0; lane < 4; ++lane) {
      input.deviatoric_left.values[lane] =
          {std::ldexp(1.0, exponent), full_low ? std::ldexp(1.0,exponent-54) : 0};
      input.deviatoric_right.values[lane] = {1.25, std::ldexp(1.0,-60)};
      input.shear_left.values[lane] = {0, 0};
      input.shear_right.values[lane] = {1,0};
      input.tensor_left.values[lane] = {-1, std::ldexp(1.0,-55)};
      input.gradient_dot.values[lane] = {std::ldexp(1.0,exponent),0};
      input.accumulated.values[lane] = {std::ldexp(1.0,exponent),0};
    }
    verify(input);
    // Mixed-low packets explicitly exercise the scalar bridge.
    input.deviatoric_left.values[1].low = 0;
    verify(input);
    input.shear_left.values[3] = {-0.0,0}; // raw signed-zero is invalid by contract
    input.deviatoric_left.values[0] = {std::numeric_limits<double>::max(),0};
    input.deviatoric_right.values[0] = {2,0};
    input.deviatoric_left.values[1] = {1,1};
    input.deviatoric_left.values[2] = {std::numeric_limits<double>::denorm_min(),0};
    input.deviatoric_right.values[2] = {0.5,0};
    verify(input);
  }
  EXPECT_GT(finite_pairs, 0U);
  EXPECT_GT(retained_low_pairs, 0U);
  EXPECT_GT(invalid_pairs, 0U);
  RecordProperty("finite_pairs", static_cast<int>(finite_pairs));
  RecordProperty("retained_low_pairs", static_cast<int>(retained_low_pairs));
  RecordProperty("invalid_pairs", static_cast<int>(invalid_pairs));
  // Selection is thread-environment dependent rather than cached after first use.
#if defined(_M_X64) || defined(__SSE2__)
  const unsigned saved = _mm_getcsr();
  _mm_setcsr(saved | 0x8000U);
  EXPECT_EQ(SelectMaterialPacketEvaluator(), EvaluateMaterialPacketScalar);
  _mm_setcsr(saved);
  EXPECT_EQ(SelectMaterialPacketEvaluator(), selected);
#endif
}
}  // namespace