Issue pyccel#983 | Add Round function and implement the conversion to C, Fortran, and Python (pyccel#996)

Add support for Python's `round` function which is implemented with a
banker's round. An integer and a floating point implementation are both
required to avoid floating point errors when handling integers. Fixes
pyccel#983.

A minor bug fix is also included to ensure that the error mode is set
back to 'user' when nothing is specified if the developer mode was used
previously.

---------

Co-authored-by: Nandini Raja <[email protected]>
Co-authored-by: Emily.Bourne <[email protected]>

Author: 3 people

AUTHORS

@@ -38,4 +38,5 @@ Contributors
 * Mohammed Ayaz Shaikh
 * Amir Movassaghi
 * Leonardo Merlin Paloschi
-* Joao Antonio Gomes
+* Joao Antonio Gomes
+* Nandini Raja

CHANGELOG.md

@@ -61,6 +61,7 @@ All notable changes to this project will be documented in this file.
 -   Add support for inhomogeneous tuple annotations.
 -   #1834 : Add support for `@property` decorator.
 -   #2099 : Fix translation of modules containing `__all__`.
+-   #983 : Add support for built-in function `round`.
 -   \[INTERNALS\] Add abstract class `SetMethod` to handle calls to various set methods.
 -   \[INTERNALS\] Added `container_rank` property to `ast.datatypes.PyccelType` objects.
 -   \[INTERNALS\] Add a `__call__` method to `FunctionDef` to create `FunctionCall` instances.

docs/builtin-functions.md

@@ -59,7 +59,7 @@ Python contains a limited number of builtin functions defined [here](https://doc
 | **`range`** | **Yes** |
 | `repr` | No |
 | `reversed` | No |
-| `round` | No |
+| **`round`** | **Yes** |
 | *`set`* | Python-only |
 | `setattr` | No  |
 | `slice` | No |

pyccel/ast/builtins.py

@@ -16,7 +16,8 @@
 
 from .basic     import PyccelAstNode, TypedAstNode
 from .datatypes import PythonNativeInt, PythonNativeBool, PythonNativeFloat
-from .datatypes import GenericType, PythonNativeComplex, PrimitiveComplexType
+from .datatypes import GenericType, PythonNativeComplex
+from .datatypes import PrimitiveBooleanType, PrimitiveComplexType
 from .datatypes import HomogeneousTupleType, InhomogeneousTupleType
 from .datatypes import HomogeneousListType, HomogeneousContainerType
 from .datatypes import FixedSizeNumericType, HomogeneousSetType, SymbolicType
@@ -53,6 +54,7 @@
     'PythonPrint',
     'PythonRange',
     'PythonReal',
+    'PythonRound',
     'PythonSet',
     'PythonSetFunction',
     'PythonSum',
@@ -480,6 +482,52 @@ def arg(self):
     def __str__(self):
         return f'float({self.arg})'
 
+# ===========================================================================
+class PythonRound(PyccelFunction):
+    """
+    Class representing a call to Python's native round() function.
+
+    Class representing a call to Python's native round() function
+    which rounds a float or integer to a given number of decimals.
+
+    Parameters
+    ----------
+    number : TypedAstNode
+        The number to be rounded.
+    ndigits : TypedAstNode, optional
+        The number of digits to round to.
+    """
+    __slots__ = ('_class_type',)
+    name = 'round'
+    _rank = 0
+    _shape = None
+    _order = None
+
+    def __init__(self, number, ndigits = None):
+        if ndigits is None or number.class_type.primitive_type is PrimitiveBooleanType():
+            self._class_type = PythonNativeInt()
+        else:
+            self._class_type = number.class_type
+        super().__init__(number, ndigits)
+
+    @property
+    def arg(self):
+        """
+        The number to be rounded.
+
+        The number to be rounded.
+        """
+        return self._args[0]
+
+    @property
+    def ndigits(self):
+        """
+        The number of digits to which the argument is rounded.
+
+        The number of digits to which the argument is rounded.
+        """
+        return self._args[1]
+
 #==============================================================================
 class PythonInt(PyccelFunction):
     """
@@ -1664,6 +1712,7 @@ def get_assign_targets(self):
     'min'      : PythonMin,
     'not'      : PyccelNot,
     'range'    : PythonRange,
+    'round'    : PythonRound,
     'set'      : PythonSetFunction,
     'str'      : LiteralString,
     'sum'      : PythonSum,

pyccel/codegen/printing/ccode.py

@@ -749,6 +749,15 @@ def _print_PythonAbs(self, expr):
             func = "labs"
         return "{}({})".format(func, self._print(expr.arg))
 
+    def _print_PythonRound(self, expr):
+        self.add_import(c_imports['pyc_math_c'])
+        arg = self._print(expr.arg)
+        ndigits = self._print(expr.ndigits or LiteralInteger(0))
+        if isinstance(expr.arg.class_type.primitive_type, (PrimitiveBooleanType, PrimitiveIntegerType)):
+            return f'ipyc_bankers_round({arg}, {ndigits})'
+        else:
+            return f'fpyc_bankers_round({arg}, {ndigits})'
+
     def _print_PythonMinMax(self, expr):
         arg = expr.args[0]
         if arg.dtype.primitive_type is PrimitiveFloatingPointType() and len(arg) == 2:

pyccel/codegen/printing/fcode.py

@@ -71,7 +71,7 @@
 from pyccel.ast.numpyext import NumpySign
 from pyccel.ast.numpyext import NumpyIsFinite, NumpyIsNan
 
-from pyccel.ast.numpytypes import NumpyNDArrayType
+from pyccel.ast.numpytypes import NumpyNDArrayType, NumpyInt64Type
 
 from pyccel.ast.operators import PyccelAdd, PyccelMul, PyccelMinus, PyccelAnd, PyccelEq
 from pyccel.ast.operators import PyccelMod, PyccelNot, PyccelAssociativeParenthesis
@@ -1198,6 +1198,25 @@ def _print_PythonAbs(self, expr):
         arg_code = self._get_node_without_gFTL(expr.arg)
         return f"abs({arg_code})"
 
+    def _print_PythonRound(self, expr):
+        arg = expr.arg
+        if not isinstance(arg.dtype.primitive_type, PrimitiveFloatingPointType):
+            arg = self._apply_cast(NumpyInt64Type(), arg)
+        self.add_import(Import('pyc_math_f90', Module('pyc_math_f90',(),())))
+
+        arg_code = self._print(arg)
+        ndigits = self._apply_cast(NumpyInt64Type(), expr.ndigits) if expr.ndigits \
+                else LiteralInteger(0, NumpyInt64Type())
+        ndigits_code = self._print(ndigits)
+
+        code = f'pyc_bankers_round({arg_code}, {ndigits_code})'
+
+        if not isinstance(expr.dtype.primitive_type, PrimitiveFloatingPointType):
+            prec = self.print_kind(expr)
+            return f"Int({code}, kind={prec})"
+        else:
+            return code
+
     def _print_PythonTuple(self, expr):
         shape = tuple(reversed(expr.shape))
         if len(shape)>1:

pyccel/codegen/printing/pycode.py

@@ -507,6 +507,14 @@ def _print_PyccelArrayShapeElement(self, expr):
         else:
             raise NotImplementedError("The shape access function seems to be poorly defined.")
 
+    def _print_PythonRound(self, expr):
+        arg = self._print(expr.arg)
+        if expr.ndigits:
+            ndigits = self._print(expr.ndigits)
+            return f'round({arg}, {ndigits})'
+        else:
+            return f'round({arg})'
+
     def _print_PyccelArraySize(self, expr):
         arg = self._print(expr.arg)
         name = self._get_numpy_name(expr)

pyccel/commands/console.py

@@ -248,11 +248,13 @@ def pyccel(files=None, mpi=None, openmp=None, openacc=None, output_dir=None, com
     # ...
 
     # ...
+    # this will initialize the singelton ErrorsMode
+    # making this settings available everywhere
+    err_mode = ErrorsMode()
     if args.developer_mode:
-        # this will initialize the singelton ErrorsMode
-        # making this settings available everywhere
-        err_mode = ErrorsMode()
         err_mode.set_mode('developer')
+    else:
+        err_mode.set_mode('user')
     # ...
 
     base_dirpath = os.getcwd()

pyccel/commands/epyccel.py

@@ -330,11 +330,13 @@ def epyccel( python_function_or_module, **kwargs ):
     comm  = kwargs.pop('comm', None)
     root  = kwargs.pop('root', 0)
     bcast = kwargs.pop('bcast', True)
+    # This will initialize the singleton ErrorsMode
+    # making this setting available everywhere
+    err_mode = ErrorsMode()
     if kwargs.pop('developer_mode', None):
-        # This will initialize the singleton ErrorsMode
-        # making this setting available everywhere
-        err_mode = ErrorsMode()
         err_mode.set_mode('developer')
+    else:
+        err_mode.set_mode('user')
 
     # Parallel version
     if comm is not None:

pyccel/stdlib/math/pyc_math_c.c

@@ -39,13 +39,6 @@ int64_t                     pyc_lcm (int64_t a, int64_t b)
     return a / pyc_gcd(a, b) * b;
 }
 /*---------------------------------------------------------------------------*/
-extern inline double        pyc_radians(double degrees);
-/*---------------------------------------------------------------------------*/
-extern inline double        pyc_degrees(double radians);
-/*---------------------------------------------------------------------------*/
-extern inline int64_t       pyc_modulo(int64_t a, int64_t b);
-/*---------------------------------------------------------------------------*/
-extern inline double        pyc_fmodulo(double a, double b);
 
 /* numpy.sign for float, double and integers */
 long long int isign(long long int x)
@@ -70,3 +63,42 @@ double complex csign(double complex x)
     double absolute = cabs(x);
     return ((absolute == 0) ? 0.0 : (x / absolute));
 }
+
+/*---------------------------------------------------------------------------*/
+
+double fpyc_bankers_round(double arg, int64_t ndigits)
+{
+    double factor = pow(10.0, ndigits);
+    arg *= factor;
+
+    double nearest_int_fix = copysign(0.5, arg);
+
+    double rnd = (int64_t)(arg + nearest_int_fix);
+
+    double diff = arg - rnd;
+
+    if (ndigits <= 0 && (diff == 0.5 || diff == -0.5)) {
+        rnd = ((int64_t)(arg*0.5 + nearest_int_fix))*2.0;
+    }
+
+    return rnd / factor;
+}
+
+int64_t ipyc_bankers_round(int64_t arg, int64_t ndigits)
+{
+    if (ndigits >= 0) {
+        return arg;
+    } else {
+        int64_t mul_fact = 1;
+        for (int i = 0; i< -ndigits; ++i) mul_fact *= 10;
+
+        int64_t pivot_point = copysign(5*mul_fact/10, arg);
+        int64_t remainder = arg % mul_fact;
+        if ( remainder == pivot_point ) {
+            int64_t val = (mul_fact - remainder) / mul_fact;
+            return (val + (val & 1)) * mul_fact;
+        } else {
+            return ((arg + pivot_point) / mul_fact) * mul_fact;
+        }
+    }
+}