[numpy] torch.sinh: promote integer inputs to float

aten/src/ATen/native/UnaryOps.cpp

@@ -343,8 +343,8 @@ Tensor& cos_out(Tensor& result, const Tensor& self) { return unary_op_impl_float
 Tensor cos(const Tensor& self) { return unary_op_impl_float(self, cos_stub); }
 Tensor& cos_(Tensor& self) { return unary_op_impl_(self, at::cos_out); }
 
-Tensor& sinh_out(Tensor& result, const Tensor& self) { return unary_op_impl_out(result, self, sinh_stub); }
-Tensor sinh(const Tensor& self) { return unary_op_impl(self, at::sinh_out); }
+Tensor& sinh_out(Tensor& result, const Tensor& self) { return unary_op_impl_float_out(result, self, sinh_stub); }
+Tensor sinh(const Tensor& self) { return unary_op_impl_float(self, sinh_stub); }
 Tensor& sinh_(Tensor& self) { return unary_op_impl_(self, at::sinh_out); }
 
 Tensor& cosh_out(Tensor& result, const Tensor& self) { return unary_op_impl_out(result, self, cosh_stub); }

aten/src/ATen/native/cuda/UnaryGeometricKernels.cu

@@ -51,7 +51,7 @@ void cos_kernel_cuda(TensorIterator& iter) {
 }
 
 void sinh_kernel_cuda(TensorIterator& iter) {
-  AT_DISPATCH_FLOATING_AND_COMPLEX_TYPES_AND1(ScalarType::Half, iter.dtype(), "sinh_cuda", [&]() {
+  AT_DISPATCH_FLOATING_AND_COMPLEX_TYPES_AND1(ScalarType::Half, iter.common_dtype(), "sinh_cuda", [&]() {
     gpu_kernel(iter, []GPU_LAMBDA(scalar_t a) -> scalar_t {
       return ::sinh(a);
     });

torch/csrc/jit/tensorexpr/kernel.cpp

@@ -1147,8 +1147,9 @@ Tensor* TensorExprKernel::computeValue(const torch::jit::Value* v) {
     } break;
 
     case aten::sinh: {
-      return computeOneOperand(
-          "aten_sinh", v, [](const ExprHandle& a) { return sinh(a); });
+      return computeOneOperand("aten_sinh", v, [](const ExprHandle& a) {
+        return sinh(promoteIntegerToFloat(a));
+      });
     } break;
 
     case aten::atan: {

torch/testing/_internal/common_methods_invocations.py

@@ -21,7 +21,8 @@
      random_symmetric_matrix, random_symmetric_psd_matrix,
      random_symmetric_pd_matrix, make_nonzero_det,
      random_fullrank_matrix_distinct_singular_value, set_rng_seed,
-     TEST_WITH_ROCM, IS_WINDOWS, IS_MACOS, make_tensor, TEST_SCIPY)
+     TEST_WITH_ROCM, IS_WINDOWS, IS_MACOS, make_tensor, TEST_SCIPY,
+     torch_to_numpy_dtype_dict)
 
 if TEST_SCIPY:
     import scipy.special
@@ -220,6 +221,33 @@ def sample_inputs(self, device, dtype, requires_grad=False):
                                         requires_grad=requires_grad)),)
 
 
+def fast_growing_function_wrapper(fn):
+    # NumPy promotes integer types to double while
+    # PyTorch promotes integer to float.
+    #
+    # This affects operators whose outputs grow very fast
+    # eg. sinh, exp, etc.
+    # To mitigate that, we force NumPy to compute with the
+    # dtype that Pytorch uses for those computations.
+    #
+    # Code Example
+    # >>> x = torch.tensor(501.)
+    # >>> x.exp()
+    # tensor(inf)
+    # >>> x = torch.tensor(501., dtype=torch.double)
+    # >>> x.exp()
+    # tensor(3.8154e+217, dtype=torch.float64)
+    def is_integral(dtype):
+        return dtype in [np.uint8, np.int8, np.int16, np.int32, np.int64]
+
+    np_dtype = torch_to_numpy_dtype_dict[torch.get_default_dtype()]
+
+    def wrapped_fn(x):
+        if is_integral(x.dtype):
+            return fn(x, dtype=np_dtype)
+        return fn(x)
+
+    return wrapped_fn
 
 # Operator database (sorted alphabetically)
 op_db = [
@@ -407,8 +435,10 @@ def sample_inputs(self, device, dtype, requires_grad=False):
                                 dtypes=[torch.float], active_if=TEST_WITH_ROCM),
                    )),
     UnaryUfuncInfo('sinh',
-                   ref=np.sinh,
-                   dtypesIfCPU=floating_and_complex_types(),
+                   ref=fast_growing_function_wrapper(np.sinh),
+                   dtypesIfCPU=all_types_and_complex_and(torch.bool),
+                   dtypesIfCUDA=all_types_and_complex_and(torch.bool, torch.half),
+                   promotes_integers_to_float=True,
                    decorators=(precisionOverride({torch.float16: 1e-2}),),
                    skips=(
                        SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
@@ -417,6 +447,9 @@ def sample_inputs(self, device, dtype, requires_grad=False):
                        SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
                                 device_type='cuda', dtypes=[torch.cfloat, torch.cdouble],
                                 active_if=IS_WINDOWS),
+                       # Reference: https://github.com/pytorch/pytorch/issues/48641
+                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
+                                device_type='cpu', dtypes=[torch.int8]),
                    )),
     UnaryUfuncInfo('tan',
                    ref=np.tan,