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)
@@ -2281,6 +2307,33 @@ def __rmod__(self, other):
         """
         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,114 @@ 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(out)))
+
+    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,6 +3,8 @@
 import numpy as np
 import heat as ht
 
+from heat.core.tests.test_suites.basic_test import BasicTest
+
 
 class TestRounding(unittest.TestCase):
     def test_abs(self):
@@ -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)
+    #      comparison = np.modf(np.arange(start, end, step, np.float32))
+    #
+    #      # exponential of float32
+    #      float32_tensor = ht.arange(start, end, step, 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.assertAlmostEqual(float32_modf[0].numpy().all(), comparison[0].all())
+    #      self.assertAlmostEqual(float32_modf[1].numpy().all(), comparison[1].all())
+    #
+    #      self.assertAlmostEqual(ht.all(float32_modf[0]), ht.all(ht.array(comparison[0])))
+    #      self.assertAlmostEqual(ht.all(float32_modf[1]), ht.all(ht.array(comparison[1])))
+    #
+    #      # exponential of float64
+    #      comparison = np.modf(np.arange(start, end, step, np.float64))
+    #
+    #      float64_tensor = ht.arange(start, end, step, 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.assertAlmostEqual(float64_modf[0].numpy().all(), comparison[0].all())
+    #      self.assertAlmostEqual(float64_modf[1].numpy().all(), comparison[1].all())
+    #
+    #      self.assertAlmostEqual(ht.all(float64_modf[0]), ht.all(ht.array(comparison[0])))
+    #      self.assertAlmostEqual(ht.all(float64_modf[1]), ht.all(ht.array(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
+    #      float32_tensor_distrbd = ht.arange(start, end, step, dtype=ht.float32, 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.assertAlmostEqual(float32_modf_distrbd[0].numpy().all(), comparison[0].all())
+    #      self.assertAlmostEqual(float32_modf_distrbd[1].numpy().all(), comparison[1].all())
+    #
+    #      self.assertAlmostEqual(ht.all(float32_modf_distrbd[0]), ht.all(ht.array(comparison[0])))
+    #      self.assertAlmostEqual(ht.all(float32_modf_distrbd[1]), ht.all(ht.array(comparison[1])))
+    #
+    #      # exponential of float64
+    #      comparison = np.modf(np.arange(start, end, step, np.float64))
+    #
+    #      float64_tensor_distrbd = ht.arange(start, end, step, dtype=ht.float64, split=0)
+    #      float64_modf_distrbd = float64_tensor_distrbd.modf()
+    #      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.assertAlmostEqual(float64_modf_distrbd[0].numpy().all(), comparison[0].all())
+    #      self.assertAlmostEqual(float64_modf_distrbd[1].numpy().all(), comparison[1].all())
+    #
+    #      self.assertAlmostEqual(ht.all(float64_modf_distrbd[0]), ht.all(ht.array(comparison[0])))
+    #      self.assertAlmostEqual(ht.all(float64_modf_distrbd[1]), ht.all(ht.array(comparison[1])))
+
+    def test_round(self):
+        size = ht.communication.MPI_WORLD.size
+        start, end = -5.0, 5.0
+        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)
+        BasicTest.assert_array_equal(self, 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)
+        BasicTest.assert_array_equal(self, 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 split tensors
+
+        # exponential of float32
+        comparison = torch.arange(start, end, step, dtype=torch.float32)  # .round()
+        float32_tensor_distrbd = ht.array(comparison, split=0)
+        comparison = comparison.round()
+        float32_round_distrbd = float32_tensor_distrbd.round()
+        self.assertIsInstance(float32_round_distrbd, ht.DNDarray)
+        self.assertEqual(float32_round_distrbd.dtype, ht.float32)
+        BasicTest.assert_array_equal(self, 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)
+        BasicTest.assert_array_equal(self, float64_round_distrbd, comparison)
+
     def test_trunc(self):
         base_array = np.random.randn(20)
 

heat/core/tests/test_suites/basic_test.py

@@ -101,7 +101,7 @@ def assert_array_equal(self, heat_array, expected_array):
 
         # Array is distributed correctly
         equal_res = np.array(compare_func(local_numpy, expected_array[slices]))
-        self.comm.Allreduce(MPI.IN_PLACE, equal_res, MPI.LAND)
+        self._comm.Allreduce(MPI.IN_PLACE, equal_res, MPI.LAND)
         self.assertTrue(equal_res, "Local tensors do not match the corresponding numpy slices.")
         self.assertEqual(
             local_numpy.dtype,