Fix implicit float-to-double promotion. (#15957)

Summary:

as titled

Differential Revision: D87749870

Author: hsharma35

kernels/portable/cpu/scalar_utils.h

@@ -221,8 +221,8 @@ bool extract_scalar(Scalar scalar, FLOAT_T* out_val) {
     // be represented when FLOAT_T == float. float can, however, represent
     // infinite and NaN values.
     if (std::isfinite(val) &&
-        (val < std::numeric_limits<FLOAT_T>::lowest() ||
-         val > std::numeric_limits<FLOAT_T>::max())) {
+        (val < static_cast<double>(std::numeric_limits<FLOAT_T>::lowest()) ||
+         val > static_cast<double>(std::numeric_limits<FLOAT_T>::max()))) {
       // PyTorch's implementation of clamp() raises an exception if the min/max
       // values cannot be represented as the dtype, so we should fail too.
       return false;

kernels/portable/cpu/util/distance_util.h

@@ -116,7 +116,7 @@ void pdist(const Tensor& in, Tensor& out, double p) {
     pdist<CTYPE, L1<CTYPE>>(in, out, p);
   } else if (p == 2.0) {
     pdist<CTYPE, L2<CTYPE>>(in, out, p);
-  } else if (p == INFINITY) {
+  } else if (p == static_cast<double>(INFINITY)) {
     pdist<CTYPE, Linf<CTYPE>>(in, out, p);
   } else {
     pdist<CTYPE, Lp<CTYPE>>(in, out, p);

kernels/portable/cpu/util/math_util.h

@@ -47,7 +47,8 @@ template <
         type = true>
 FLOAT_T floor_divide(FLOAT_T a, FLOAT_T b) {
   if (b == 0) {
-    return std::signbit(a) ? -INFINITY : INFINITY;
+    return std::signbit(a) ? static_cast<FLOAT_T>(-INFINITY)
+                           : static_cast<FLOAT_T>(INFINITY);
   }
   const auto mod = std::fmod(a, b);
   auto div = (a - mod) / b;

runtime/core/exec_aten/testing_util/tensor_util.cpp

@@ -54,8 +54,9 @@ bool element_is_close(const T a, const T b, double rtol, double atol) {
         return false;
       }
     } else {
-      auto allowed_error = atol + std::abs(rtol * b);
-      auto actual_error = std::abs(a - b);
+      const double allowed_error =
+          atol + std::abs(rtol * static_cast<double>(b));
+      const double actual_error = static_cast<double>(std::abs(a - b));
       if (!std::isfinite(actual_error) || actual_error > allowed_error) {
         return false;
       }