Features/125 modf

heat/core/dndarray.py

@@ -1894,6 +1894,32 @@ def __mod__(self, other):
         """
         return arithmetics.mod(self, other)
 
+    def modf(a, out=None):
+        """
+        Return the fractional and integral parts of an array, element-wise.
+        The fractional and integral parts are negative if the given number is negative.
+
+        Parameters
+        ----------
+        x : ht.DNDarray
+            Input array
+        out : ht.DNDarray, optional
+            A location into which the result is stored. If provided, it must have a shape that the inputs broadcast to.
+            If not provided or None, a freshly-allocated array is returned.
+
+        Returns
+        -------
+        tuple(ht.DNDarray: fractionalParts, ht.DNDarray: integralParts)
+
+        fractionalParts : ht.DNDdarray
+            Fractional part of x. This is a scalar if x is a scalar.
+
+        integralParts : ht.DNDdarray
+            Integral part of x. This is a scalar if x is a scalar.
+        """
+
+        return rounding.modf(a, out)
+
     def __mul__(self, other):
         """
         Element-wise multiplication (not matrix multiplication) with values from second operand (scalar or tensor)
@@ -2277,10 +2303,35 @@ def __rmod__(self, other):
         >>> T = ht.int32([1, 3])
         >>> 2 % T
         tensor([0, 2], dtype=torch.int32)
-
         """
         return arithmetics.mod(other, self)
 
+    def round(x, decimals=0, out=None, dtype=None):
+        """
+        Calculate the rounded value element-wise.
+
+        Parameters
+        ----------
+        x : ht.DNDarray
+            The values for which the compute the rounded value.
+        out : ht.DNDarray, optional
+            A location into which the result is stored. If provided, it must have a shape that the inputs broadcast to.
+            If not provided or None, a freshly-allocated array is returned.
+        dtype : ht.type, optional
+            Determines the data type of the output array. The values are cast to this type with potential loss of
+            precision.
+
+        decimals: int, optional
+            Number of decimal places to round to (default: 0).
+            If decimals is negative, it specifies the number of positions to the left of the decimal point.
+
+        Returns
+        -------
+        rounded_values : ht.DNDarray
+            A tensor containing the rounded value of each element in x.
+        """
+        return rounding.round(x, decimals, out, dtype)
+
     def __rpow__(self, other):
         """
         Element-wise exponential function of second operand (not-heat-typed) with values from first operand (tensor).

heat/core/rounding.py

@@ -4,7 +4,7 @@
 from . import dndarray
 from . import types
 
-__all__ = ["abs", "absolute", "ceil", "clip", "fabs", "floor", "trunc"]
+__all__ = ["abs", "absolute", "ceil", "clip", "fabs", "floor", "modf", "round", "trunc"]
 
 
 def abs(x, out=None, dtype=None):
@@ -178,6 +178,113 @@ def floor(x, out=None):
     return operations.__local_op(torch.floor, x, out)
 
 
+def modf(x, out=None):
+    """
+    Return the fractional and integral parts of a tensor, element-wise.
+    The fractional and integral parts are negative if the given number is negative.
+
+    Parameters
+    ----------
+    x : ht.DNDarray
+        Input tensor
+    out : tuple(ht.DNDarray, ht.DNDarray), optional
+        A location into which the result is stored. If provided, it must have a shape that the inputs broadcast to.
+        If not provided or None, a freshly-allocated tensor is returned.
+
+    Returns
+    -------
+    tuple(ht.DNDarray: fractionalParts, ht.DNDarray: integralParts)
+
+    fractionalParts : ht.DNDdarray
+        Fractional part of x. This is a scalar if x is a scalar.
+
+    integralParts : ht.DNDdarray
+        Integral part of x. This is a scalar if x is a scalar.
+
+    Examples
+    --------
+    >>> ht.modf(ht.arange(-2.0, 2.0, 0.4))
+        (tensor([-2., -1., -1., -0., -0.,  0.,  0.,  0.,  1.,  1.]),
+        tensor([ 0.0000, -0.6000, -0.2000, -0.8000, -0.4000,  0.0000,  0.4000,  0.8000, 0.2000,  0.6000]))
+    """
+    if not isinstance(x, dndarray.DNDarray):
+        raise TypeError("expected x to be a ht.DNDarray, but was {}".format(type(x)))
+
+    integralParts = trunc(x)
+    fractionalParts = x - integralParts
+
+    if out is not None:
+        if not isinstance(out, tuple):
+            raise TypeError(
+                "expected out to be None or a tuple of ht.DNDarray, but was {}".format(type(out))
+            )
+        if len(out) != 2:
+            raise ValueError(
+                "expected out to be a tuple of length 2, but was of length {}".format(len(out))
+            )
+        if (not isinstance(out[0], dndarray.DNDarray)) or (
+            not isinstance(out[1], dndarray.DNDarray)
+        ):
+            raise TypeError(
+                "expected out to be None or a tuple of ht.DNDarray, but was ({}, {})".format(
+                    type(out[0]), type(out[1])
+                )
+            )
+        out[0]._DNDarray__array = fractionalParts._DNDarray__array
+        out[1]._DNDarray__array = integralParts._DNDarray__array
+        return out
+
+    return (fractionalParts, integralParts)
+
+
+def round(x, decimals=0, out=None, dtype=None):
+    """
+    Calculate the rounded value element-wise.
+
+    Parameters
+    ----------
+    x : ht.DNDarray
+        The values for which the compute the rounded value.
+    decimals: int, optional
+        Number of decimal places to round to (default: 0).
+        If decimals is negative, it specifies the number of positions to the left of the decimal point.
+    out : ht.DNDarray, optional
+        A location into which the result is stored. If provided, it must have a shape that the inputs broadcast to.
+        If not provided or None, a freshly-allocated array is returned.
+    dtype : ht.type, optional
+        Determines the data type of the output array. The values are cast to this type with potential loss of
+        precision.
+
+
+    Returns
+    -------
+    rounded_values : ht.DNDarray
+        A tensor containing the rounded value of each element in x.
+
+    Examples
+    --------
+    >>> ht.round(ht.arange(-2.0, 2.0, 0.4))
+        tensor([-2., -2., -1., -1., -0.,  0.,  0.,  1.,  1.,  2.])
+
+    """
+    if dtype is not None and not issubclass(dtype, types.generic):
+        raise TypeError("dtype must be a heat data type")
+
+    if decimals != 0:
+        x *= 10 ** decimals
+
+    rounded_values = operations.__local_op(torch.round, x, out)
+
+    if decimals != 0:
+        rounded_values /= 10 ** decimals
+
+    if dtype is not None:
+        rounded_values._DNDarray__array = rounded_values._DNDarray__array.type(dtype.torch_type())
+        rounded_values._DNDarray__dtype = dtype
+
+    return rounded_values
+
+
 def trunc(x, out=None):
     """
     Return the trunc of the input, element-wise.

heat/core/tests/test_rounding.py

@@ -3,8 +3,10 @@
 import numpy as np
 import heat as ht
 
+from heat.core.tests.test_suites.basic_test import BasicTest
 
-class TestRounding(unittest.TestCase):
+
+class TestRounding(BasicTest):
     def test_abs(self):
         # for abs==absolute
         float32_tensor = ht.arange(-10, 10, dtype=ht.float32, split=0)
@@ -162,6 +164,139 @@ def test_floor(self):
         with self.assertRaises(TypeError):
             ht.floor(object())
 
+    def test_modf(self):
+        size = ht.communication.MPI_WORLD.size
+        start, end = -5.0, 5.0
+        step = (end - start) / (2 * size)
+        npArray = np.arange(start, end, step, dtype=np.float32)
+        comparison = np.modf(npArray)
+
+        # exponential of float32
+        float32_tensor = ht.array(npArray, dtype=ht.float32)
+        float32_modf = float32_tensor.modf()
+        self.assertIsInstance(float32_modf[0], ht.DNDarray)
+        self.assertIsInstance(float32_modf[1], ht.DNDarray)
+        self.assertEqual(float32_modf[0].dtype, ht.float32)
+        self.assertEqual(float32_modf[1].dtype, ht.float32)
+
+        self.assert_array_equal(float32_modf[0], comparison[0])
+        self.assert_array_equal(float32_modf[1], comparison[1])
+
+        # exponential of float64
+        npArray = np.arange(start, end, step, np.float64)
+        comparison = np.modf(npArray)
+
+        float64_tensor = ht.array(npArray, dtype=ht.float64)
+        float64_modf = float64_tensor.modf()
+        self.assertIsInstance(float64_modf[0], ht.DNDarray)
+        self.assertIsInstance(float64_modf[1], ht.DNDarray)
+        self.assertEqual(float64_modf[0].dtype, ht.float64)
+        self.assertEqual(float64_modf[1].dtype, ht.float64)
+
+        self.assert_array_equal(float64_modf[0], comparison[0])
+        self.assert_array_equal(float64_modf[1], comparison[1])
+
+        # check exceptions
+        with self.assertRaises(TypeError):
+            ht.modf([0, 1, 2, 3])
+        with self.assertRaises(TypeError):
+            ht.modf(object())
+        with self.assertRaises(TypeError):
+            ht.modf(float32_tensor, 1)
+        with self.assertRaises(ValueError):
+            ht.modf(float32_tensor, (float32_tensor, float32_tensor, float64_tensor))
+        with self.assertRaises(TypeError):
+            ht.modf(float32_tensor, (float32_tensor, 2))
+
+        # with split tensors
+
+        # exponential of float32
+        npArray = np.arange(start, end, step, dtype=np.float32)
+        comparison = np.modf(npArray)
+        float32_tensor_distrbd = ht.array(npArray, split=0)
+        float32_modf_distrbd = float32_tensor_distrbd.modf()
+
+        self.assertIsInstance(float32_modf_distrbd[0], ht.DNDarray)
+        self.assertIsInstance(float32_modf_distrbd[1], ht.DNDarray)
+        self.assertEqual(float32_modf_distrbd[0].dtype, ht.float32)
+        self.assertEqual(float32_modf_distrbd[1].dtype, ht.float32)
+
+        self.assert_array_equal(float32_modf_distrbd[0], comparison[0])
+        self.assert_array_equal(float32_modf_distrbd[1], comparison[1])
+
+        # exponential of float64
+        npArray = npArray = np.arange(start, end, step, np.float64)
+        comparison = np.modf(npArray)
+
+        float64_tensor_distrbd = ht.array(npArray, split=0)
+        float64_modf_distrbd = (
+            ht.zeros_like(float64_tensor_distrbd, dtype=float64_tensor_distrbd.dtype),
+            ht.zeros_like(float64_tensor_distrbd, dtype=float64_tensor_distrbd.dtype),
+        )
+        # float64_modf_distrbd = float64_tensor_distrbd.modf()
+        float64_tensor_distrbd.modf(out=float64_modf_distrbd)
+        self.assertIsInstance(float64_modf_distrbd[0], ht.DNDarray)
+        self.assertIsInstance(float64_modf_distrbd[1], ht.DNDarray)
+        self.assertEqual(float64_modf_distrbd[0].dtype, ht.float64)
+        self.assertEqual(float64_modf_distrbd[1].dtype, ht.float64)
+
+        self.assert_array_equal(float64_modf_distrbd[0], comparison[0])
+        self.assert_array_equal(float64_modf_distrbd[1], comparison[1])
+
+    def test_round(self):
+        size = ht.communication.MPI_WORLD.size
+        start, end = -5.7, 5.1
+        step = (end - start) / (2 * size)
+        comparison = torch.arange(start, end, step, dtype=torch.float32).round()
+
+        # exponential of float32
+        float32_tensor = ht.array(comparison, dtype=ht.float32)
+        float32_round = float32_tensor.round()
+        self.assertIsInstance(float32_round, ht.DNDarray)
+        self.assertEqual(float32_round.dtype, ht.float32)
+        self.assertEqual(float32_round.dtype, ht.float32)
+        self.assert_array_equal(float32_round, comparison)
+
+        # exponential of float64
+        comparison = torch.arange(start, end, step, dtype=torch.float64).round()
+        float64_tensor = ht.array(comparison, dtype=ht.float64)
+        float64_round = float64_tensor.round()
+        self.assertIsInstance(float64_round, ht.DNDarray)
+        self.assertEqual(float64_round.dtype, ht.float64)
+        self.assertEqual(float64_round.dtype, ht.float64)
+        self.assert_array_equal(float64_round, comparison)
+
+        # check exceptions
+        with self.assertRaises(TypeError):
+            ht.round([0, 1, 2, 3])
+        with self.assertRaises(TypeError):
+            ht.round(object())
+        with self.assertRaises(TypeError):
+            ht.round(float32_tensor, 1, 1)
+        with self.assertRaises(TypeError):
+            ht.round(float32_tensor, dtype=np.int)
+
+        # with split tensors
+
+        # exponential of float32
+        comparison = torch.arange(start, end, step, dtype=torch.float32)  # .round()
+        float32_tensor_distrbd = ht.array(comparison, split=0, dtype=ht.double)
+        comparison = comparison.round()
+        float32_round_distrbd = float32_tensor_distrbd.round(dtype=ht.float)
+        self.assertIsInstance(float32_round_distrbd, ht.DNDarray)
+        self.assertEqual(float32_round_distrbd.dtype, ht.float32)
+        self.assert_array_equal(float32_round_distrbd, comparison)
+
+        # exponential of float64
+        comparison = torch.arange(start, end, step, dtype=torch.float64)  # .round()
+        float64_tensor_distrbd = ht.array(comparison, split=0)
+        comparison = comparison.round()
+        float64_round_distrbd = float64_tensor_distrbd.round()
+        self.assertIsInstance(float64_round_distrbd, ht.DNDarray)
+        self.assertEqual(float64_round_distrbd.dtype, ht.float64)
+        self.assertEqual(float64_round_distrbd.dtype, ht.float64)
+        self.assert_array_equal(float64_round_distrbd, comparison)
+
     def test_trunc(self):
         base_array = np.random.randn(20)
 

heat/core/tests/test_suites/basic_test.py

@@ -107,12 +107,14 @@ def assert_array_equal(self, heat_array, expected_array):
         local_numpy = heat_array._DNDarray__array.numpy()
 
         equal_res = np.array(compare_func(local_numpy, expected_array[slices]))
+
         self.comm.Allreduce(MPI.IN_PLACE, equal_res, MPI.LAND)
         self.assertTrue(
             equal_res,
             "Local tensors do not match the corresponding numpy slices. "
             "dtype was {}, split was {}".format(heat_array.dtype, heat_array.split),
         )
+
         self.assertEqual(
             local_numpy.dtype,
             expected_array.dtype,