[libc] Extend MPFRMatcher to handle 2-input-1-output and support hypot function.

[sivachandra]

libc/utils/MPFRWrapper/MPFRUtils.cpp

544

This is now repeated in two other functions also I think. We should probably use a helper function, but can be done in a later pass.

libc/utils/MPFRWrapper/MPFRUtils.h

50

Can you remove the TODO?

166

Can you remove the TODO here as well?

[lntue]

libc/utils/MPFRWrapper/MPFRUtils.cpp

544

Ack

[lntue]

Remove TODO's.

libc/utils/MPFRWrapper/MPFRUtils.h

enum class Operation : int {
   BeginUnaryOperationsTwoOutputs,
   Frexp, // Floating point output, the first output, is the fractional part.
   EndUnaryOperationsTwoOutputs,
 
   // Operations wich take two floating point nubmers of the same type as
   // input and produce a single floating point number of the same type as
   // output.
   BeginBinaryOperationsSingleOutput,
-  // TODO: Add operations like hypot.
+  Hypot,
   EndBinaryOperationsSingleOutput,
 
   // Operations which take two floating point numbers of the same type as
   // input and produce two outputs. The first output is a floating nubmer of
   // the same type as the inputs. The second output is af type 'int'.
   BeginBinaryOperationsTwoOutputs,
   RemQuo, // The first output, the floating point output, is the remainder.
   EndBinaryOperationsTwoOutputs,
bool compareUnaryOperationTwoOutputs(Operation op, T input,
                                      const BinaryOutput<T> &libcOutput,
                                      double t);
 template <typename T>
 bool compareBinaryOperationTwoOutputs(Operation op, const BinaryInput<T> &input,
                                       const BinaryOutput<T> &libcOutput,
                                       double t);
 
 template <typename T>
+bool compareBinaryOperationOneOutput(Operation op, const BinaryInput<T> &input,
+                                     T libcOutput, double t);
+
+template <typename T>
 void explainUnaryOperationSingleOutputError(Operation op, T input, T matchValue,
                                             testutils::StreamWrapper &OS);
 template <typename T>
 void explainUnaryOperationTwoOutputsError(Operation op, T input,
                                           const BinaryOutput<T> &matchValue,
                                           testutils::StreamWrapper &OS);
 template <typename T>
 void explainBinaryOperationTwoOutputsError(Operation op,
                                            const BinaryInput<T> &input,
                                            const BinaryOutput<T> &matchValue,
                                            testutils::StreamWrapper &OS);
 
+template <typename T>
+void explainBinaryOperationOneOutputError(Operation op,
+                                          const BinaryInput<T> &input,
+                                          T matchValue,
+                                          testutils::StreamWrapper &OS);
+
 template <Operation op, typename InputType, typename OutputType>
 class MPFRMatcher : public testing::Matcher<OutputType> {
   InputType input;
   OutputType matchValue;
   double ulpTolerance;
 
 public:
   MPFRMatcher(InputType testInput, double ulpTolerance)
private:
 
   template <typename T>
   static bool match(T in, const BinaryOutput<T> &out, double tolerance) {
     return compareUnaryOperationTwoOutputs(op, in, out, tolerance);
   }
 
   template <typename T>
   static bool match(const BinaryInput<T> &in, T out, double tolerance) {
-    // TODO: Implement the comparision function and error reporter.
+    return compareBinaryOperationOneOutput(op, in, out, tolerance);
   }
 
   template <typename T>
   static bool match(BinaryInput<T> in, const BinaryOutput<T> &out,
                     double tolerance) {
     return compareBinaryOperationTwoOutputs(op, in, out, tolerance);
   }
 
static void explainError(T in, const BinaryOutput<T> &out,
     explainUnaryOperationTwoOutputsError(op, in, out, OS);
   }
 
   template <typename T>
   static void explainError(const BinaryInput<T> &in, const BinaryOutput<T> &out,
                            testutils::StreamWrapper &OS) {
     explainBinaryOperationTwoOutputsError(op, in, out, OS);
   }
+
+  template <typename T>
+  static void explainError(const BinaryInput<T> &in, T out,
+                           testutils::StreamWrapper &OS) {
+    explainBinaryOperationOneOutputError(op, in, out, OS);
+  }
 };
 
 } // namespace internal
 
 // Return true if the input and ouput types for the operation op are valid
 // types.
 template <Operation op, typename InputType, typename OutputType>
 constexpr bool isValidOperation() {

libc/utils/MPFRWrapper/MPFRUtils.cpp

 #ifdef CUSTOM_MPFR_INCLUDER
 // Some downstream repos are monoliths carrying MPFR sources in their third
 // party directory. In such repos, including the MPFR header as
 // `#include <mpfr.h>` is either disallowed or not possible. If that is the
 // case, a file named `CustomMPFRIncluder.h` should be added through which the
 // MPFR header can be included in manner allowed in that repo.
 #include "CustomMPFRIncluder.h"
 #else
 #include <mpfr.h>
 #endif
 
 template <typename T> using FPBits = __llvm_libc::fputil::FPBits<T>;
 
 namespace __llvm_libc {
 namespace testing {
 namespace mpfr {
 
public:
   MPFRNumber frexp(int &exp) {
     MPFRNumber result;
     mpfr_exp_t resultExp;
     mpfr_frexp(&resultExp, result.value, value, MPFR_RNDN);
     exp = resultExp;
     return result;
   }
 
+  MPFRNumber hypot(const MPFRNumber &b) {
+    MPFRNumber result;
+    mpfr_hypot(result.value, value, b.value, MPFR_RNDN);
+    return result;
+  }
+
   MPFRNumber remquo(const MPFRNumber &divisor, int &quotient) {
     MPFRNumber remainder;
     long q;
     mpfr_remquo(remainder.value, &q, value, divisor.value, MPFR_RNDN);
     quotient = q;
     return remainder;
   }
 
case Operation::Frexp:
     return mpfrInput.frexp(output);
   default:
     __builtin_unreachable();
   }
 }
 
 template <typename InputType>
 cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
+binaryOperationOneOutput(Operation op, InputType x, InputType y) {
+  MPFRNumber inputX(x), inputY(y);
+  switch (op) {
+  case Operation::Hypot:
+    return inputX.hypot(inputY);
+  default:
+    __builtin_unreachable();
+  }
+}
+
+template <typename InputType>
+cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
 binaryOperationTwoOutputs(Operation op, InputType x, InputType y, int &output) {
   MPFRNumber inputX(x), inputY(y);
   switch (op) {
   case Operation::RemQuo:
     return inputX.remquo(inputY, output);
   default:
     __builtin_unreachable();
   }

 template void explainBinaryOperationTwoOutputsError<double>(
     Operation, const BinaryInput<double> &, const BinaryOutput<double> &,
     testutils::StreamWrapper &);
 template void explainBinaryOperationTwoOutputsError<long double>(
     Operation, const BinaryInput<long double> &,
     const BinaryOutput<long double> &, testutils::StreamWrapper &);
 
 template <typename T>
+void explainBinaryOperationOneOutputError(Operation op,
+                                          const BinaryInput<T> &input,
+                                          T libcResult,
+                                          testutils::StreamWrapper &OS) {
+  MPFRNumber mpfrX(input.x);
+  MPFRNumber mpfrY(input.y);
+  FPBits<T> xbits(input.x);
+  FPBits<T> ybits(input.y);
+  MPFRNumber mpfrResult = binaryOperationOneOutput(op, input.x, input.y);
+  MPFRNumber mpfrMatchValue(libcResult);
+
+  OS << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n';
+  __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x,
+                                              OS);
+  __llvm_libc::fputil::testing::describeValue("Second input bits: ", input.y,
+                                              OS);
+
+  OS << "Libc result: " << mpfrMatchValue.str() << '\n'
+     << "MPFR result: " << mpfrResult.str() << '\n';
+  __llvm_libc::fputil::testing::describeValue(
+      "Libc floating point result bits: ", libcResult, OS);
+  __llvm_libc::fputil::testing::describeValue(
+      "              MPFR rounded bits: ", mpfrResult.as<T>(), OS);
+  OS << "ULP error: " << std::to_string(mpfrResult.ulp(libcResult)) << '\n';
+}
+
+template void explainBinaryOperationOneOutputError<float>(
+    Operation, const BinaryInput<float> &, float, testutils::StreamWrapper &);
+template void explainBinaryOperationOneOutputError<double>(
+    Operation, const BinaryInput<double> &, double, testutils::StreamWrapper &);
+template void explainBinaryOperationOneOutputError<long double>(
+    Operation, const BinaryInput<long double> &, long double,
+    testutils::StreamWrapper &);
+
+template <typename T>
 bool compareUnaryOperationSingleOutput(Operation op, T input, T libcResult,
                                        double ulpError) {
   // If the ulp error is exactly 0.5 (i.e a tie), we would check that the result
   // is rounded to the nearest even.
   MPFRNumber mpfrResult = unaryOperation(op, input);
   double ulp = mpfrResult.ulp(libcResult);
   bool bitsAreEven = ((FPBits<T>(libcResult).bitsAsUInt() & 1) == 0);
   return (ulp < ulpError) ||
compareBinaryOperationTwoOutputs<float>(Operation, const BinaryInput<float> &,
                                         const BinaryOutput<float> &, double);
 template bool
 compareBinaryOperationTwoOutputs<double>(Operation, const BinaryInput<double> &,
                                          const BinaryOutput<double> &, double);
 template bool compareBinaryOperationTwoOutputs<long double>(
     Operation, const BinaryInput<long double> &,
     const BinaryOutput<long double> &, double);
 
+template <typename T>
+bool compareBinaryOperationOneOutput(Operation op, const BinaryInput<T> &input,
+                                     T libcResult, double ulpError) {
+  MPFRNumber mpfrResult = binaryOperationOneOutput(op, input.x, input.y);
+  double ulp = mpfrResult.ulp(libcResult);
+
+  bool bitsAreEven = ((FPBits<T>(libcResult).bitsAsUInt() & 1) == 0);
+  return (ulp < ulpError) ||
+         ((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
+}
+
+template bool compareBinaryOperationOneOutput<float>(Operation,
+                                                     const BinaryInput<float> &,
+                                                     float, double);
+template bool
+compareBinaryOperationOneOutput<double>(Operation, const BinaryInput<double> &,
+                                        double, double);
+template bool compareBinaryOperationOneOutput<long double>(
+    Operation, const BinaryInput<long double> &, long double, double);
+
 } // namespace internal
 
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc