349: Implemented round() function

temporian/core/event_set_ops.py

@@ -1501,6 +1501,38 @@ def abs(
 
         return abs(self)
 
+    def __round__(self):
+        from temporian.core.operators.unary import round
+
+        return round(input=self)
+
+    def round(
+        self: EventSetOrNode,
+    ) -> EventSetOrNode:
+        """Rounds the values of an [`EventSet`][temporian.EventSet]'s features to the nearest integer.
+
+        Example:
+            ```python
+            >>> a = tp.event_set(
+            ...     timestamps=[1, 2, 3],
+            ...     features={"M": [1.4, 2.6, 3.1], "N":  [-1.9, -3.5, 5.8]},
+            ... )
+            >>> a.round()
+            indexes: ...
+                    'M': [1, 3, 3]
+                    'N': [-2, -4, 6]
+            ...
+
+            ```
+
+        Returns:
+            EventSet with rounded feature values.
+        """
+        from temporian.core.operators.unary import round
+
+        return round(self)
+
+
     def add_index(
         self: EventSetOrNode, indexes: Union[str, List[str]]
     ) -> EventSetOrNode:
@@ -2895,6 +2927,7 @@ def log(self: EventSetOrNode) -> EventSetOrNode:
 
         return log(self)
 
+
     def moving_count(
         self: EventSetOrNode,
         window_length: WindowLength,

temporian/core/operators/unary.py

@@ -182,11 +182,30 @@ def get_output_dtype(cls, feature_dtype: DType) -> DType:
         return feature_dtype
 
 
+class RoundOperator(BaseUnaryOperator):
+    @classmethod
+    def op_key_definition(cls) -> str:
+        return "ROUND"
+
+    @classmethod
+    def allowed_dtypes(cls) -> List[DType]:
+        return [
+            DType.INT32,
+            DType.INT64,
+        ]
+
+    @classmethod
+    def get_output_dtype(cls, feature_dtype: DType) -> DType:
+        return feature_dtype
+
+
 operator_lib.register_operator(InvertOperator)
 operator_lib.register_operator(IsNanOperator)
 operator_lib.register_operator(NotNanOperator)
 operator_lib.register_operator(AbsOperator)
 operator_lib.register_operator(LogOperator)
+operator_lib.register_operator(RoundOperator)
+
 
 
 @compile
@@ -242,3 +261,14 @@ def log(
     return LogOperator(
         input=input,
     ).outputs["output"]
+
+
+@compile
+def round(
+    input: EventSetOrNode,
+) -> EventSetOrNode:
+    assert isinstance(input, EventSetNode)
+
+    return RoundOperator(
+        input=input,
+    ).outputs["output"]

temporian/implementation/numpy/operators/unary.py

@@ -10,6 +10,7 @@
     NotNanOperator,
     IsNanOperator,
     LogOperator,
+    RoundOperator,
 )
 from temporian.implementation.numpy import implementation_lib
 from temporian.implementation.numpy.data.event_set import IndexData
@@ -77,6 +78,11 @@ def _do_operation(self, feature: np.ndarray) -> np.ndarray:
         return np.log(feature)
 
 
+class RoundNumpyImplementation(BaseUnaryNumpyImplementation):
+    def _do_operation(self, feature: np.ndarray) -> np.ndarray:
+        return np.round(feature)
+
+
 implementation_lib.register_operator_implementation(
     AbsOperator, AbsNumpyImplementation
 )
@@ -92,3 +98,6 @@ def _do_operation(self, feature: np.ndarray) -> np.ndarray:
 implementation_lib.register_operator_implementation(
     LogOperator, LogNumpyImplementation
 )
+implementation_lib.register_operator_implementation(
+    RoundOperator, RoundNumpyImplementation
+)