pytorch · krshrimali · May 10, 2021 · May 10, 2021 · May 10, 2021 · May 10, 2021
diff --git a/torch/_torch_docs.py b/torch/_torch_docs.py
@@ -3274,12 +3274,11 @@ def merge_dicts(*dicts):
            r"""
 fmod(input, other, *, out=None) -> Tensor
 
-Computes the element-wise remainder of division with the remainder having the same
-sign as the dividend :attr:`input`.
+Applies C++'s `std::fmod <https://en.cppreference.com/w/cpp/numeric/math/fmod>`_
+for floating point tensors, and the modulus operation for integer tensors. The result
+has the same sign as the dividend :attr:`input` and its absolute value
+is less than that of :attr:`other`.
 
-.. math::
-    \text{{out}}_i = \text{{input}}_i - trunc(\frac{\text{{input}}_i}{\text{{other}}_i}) * \text{{other}}_i
-""" + r"""
 Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
 :ref:`type promotion <type-promotion-doc>`, and integer and float inputs.
 
@@ -3294,13 +3293,6 @@ def merge_dicts(*dicts):
    Complex inputs are not supported. In some cases, it is not mathematically
    possible to satisfy the definition of a modulo operation with complex numbers.
 
-.. seealso::
-
-    :func:`torch.fmod` truncates (rounded towards zero) the quotient with the
-    output having same sign as the dividend :attr:`input` while
-    :func:`torch.remainder` rounds (towards the nearest even integer) the quotient
-    with the output having same sign as the divisor :attr:`other`.
-
 Args:
     input (Tensor): the dividend
     other (Tensor or Scalar): the divisor
@@ -3315,6 +3307,11 @@ def merge_dicts(*dicts):
     >>> torch.fmod(torch.tensor([1, 2, 3, 4, 5]), -1.5)
     tensor([1.0000, 0.5000, 0.0000, 1.0000, 0.5000])
 
+.. seealso::
+
+    :func:`torch.remainder` which is similar to :func:`torch.fmod` except that if the sign
+    of the modulus is different than the sign of the divisor :attr:`other` then the divisor
+    is added to the modulus.
 """.format(**common_args))
 
 add_docstr(torch.frac,
@@ -7640,12 +7637,11 @@ def merge_dicts(*dicts):
            r"""
 remainder(input, other, *, out=None) -> Tensor
 
-Computes the element-wise remainder of division with the remainder having the same
-sign as the divisor :attr:`other`.
+Like :func:`torch.fmod` this applies C++'s `std::fmod <https://en.cppreference.com/w/cpp/numeric/math/fmod>`_
+for floating point tensors and the modulus operation for integer tensors.
+Unlike :func:`torch.fmod`, however, if the sign of the modulus is different
+than the sign of the divisor :attr:`other` then the divisor is added to the modulus.
 
-.. math::
-    \text{{out}}_i = \text{{input}}_i - round(\frac{\text{{input}}_i}{\text{{other}}_i}) * \text{{other}}_i
-""" + r"""
 Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
 :ref:`type promotion <type-promotion-doc>`, and integer and float inputs.
 
@@ -7654,13 +7650,6 @@ def merge_dicts(*dicts):
     possible to satisfy the definition of a modulo operation with complex numbers.
     See :func:`torch.fmod` for how division by zero is handled.
 
-.. seealso::
-
-    :func:`torch.fmod` truncates (rounded towards zero) the quotient with the
-    output having same sign as the dividend :attr:`input` while
-    :func:`torch.remainder` rounds (towards the nearest even integer) the quotient
-    with the output having same sign as the divisor :attr:`other`.
-
 Args:
     input (Tensor): the dividend
     other (Tensor or Scalar): the divisor
@@ -7677,9 +7666,9 @@ def merge_dicts(*dicts):
 
 .. seealso::
 
-        :func:`torch.fmod`, which computes the element-wise remainder of
-        division equivalently to the C library function ``fmod()``.
-
+    :func:`torch.fmod` which just computes the modulus for integer inputs and
+    applies C++'s `std::fmod <https://en.cppreference.com/w/cpp/numeric/math/fmod>`_
+    for floating point inputs.
 """.format(**common_args))
 
 add_docstr(torch.renorm,

diff --git a/torch/testing/_internal/common_utils.py b/torch/testing/_internal/common_utils.py
@@ -1724,7 +1724,7 @@ def f_retry(*args, **kwargs):
 
 def make_tensor(size, device: torch.device, dtype: torch.dtype, *, low=None, high=None,
                 requires_grad: bool = False, noncontiguous: bool = False,
-                exclude_values: list = None) -> torch.Tensor:
+                exclude_zero: bool = False) -> torch.Tensor:
     """ Creates a random tensor with the given size, device and dtype.
 
         By default, the tensor's values are in the range [-9, 9] for most dtypes. If low
@@ -1737,9 +1737,7 @@ def make_tensor(size, device: torch.device, dtype: torch.dtype, *, low=None, hig
         specifies a tensor with a 1 or 0 elements in which case the noncontiguous parameter is ignored because
         it is not possible to create a noncontiguous Tensor with a single element.
 
-        If exclude_values is passed with a list of values (default is empty list), all the matching values
-        in the created tensor are replaced with an epsilon value if floating type, [`eps` + `eps`.j] if complex type
-        and 1 if integer/boolean type.
+        If exclude_zero is passed with True (default is False), all the matching values (with zero) in created tensor are replaced with an epsilon value if floating type, [`eps + `eps`.j] if complex type and 1 if integer/boolean type.
     """
 
     assert low is None or low < 9, "low value too high!"
@@ -1778,7 +1776,7 @@ def make_tensor(size, device: torch.device, dtype: torch.dtype, *, low=None, hig
         result = torch.repeat_interleave(result, 2, dim=-1)
         result = result[..., ::2]
 
-    if exclude_values:
+    if exlude_zero:
         if dtype in integral_types() or dtype is torch.bool:
             replace_with = torch.tensor(1, device=device, dtype=dtype)
         elif dtype in floating_types_and(torch.half, torch.bfloat16):
@@ -1789,11 +1787,7 @@ def make_tensor(size, device: torch.device, dtype: torch.dtype, *, low=None, hig
             real = torch.tensor(torch.finfo(float_dtype).eps, device=device, dtype=dtype)
             imag = torch.tensor(torch.finfo(float_dtype).eps, device=device, dtype=dtype)
             replace_with = torch.complex(real, imag)
-        for exclude_val in exclude_values:
-            if dtype is torch.bool:
-                result[result == exclude_val] = replace_with
-            else:
-                result[result == exclude_val] = exclude_val + replace_with
+        result[result == 0] = replace_with
 
     if dtype in floating_types_and(torch.half, torch.bfloat16) or\
        dtype in complex_types():