Builtins frontend

ivy/functional/frontends/builtins/__init__.py

@@ -0,0 +1,5 @@
+from . import func_wrapper
+from .func_wrapper import *
+from . import built_in_functions
+from .built_in_functions import *
+from . import math

ivy/functional/frontends/builtins/built_in_functions.py

@@ -0,0 +1,90 @@
+import ivy
+import ivy.functional.frontends.builtins as builtins_frontend
+from ivy.functional.frontends.builtins.func_wrapper import (
+    from_zero_dim_arrays_to_scalar,
+    to_ivy_arrays_and_back,
+)
+
+
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def abs(x):
+    return ivy.abs(x)
+
+
+@to_ivy_arrays_and_back
+def range(start, /, stop=None, step=1):
+    if not stop:
+        return ivy.arange(0, stop=start, step=step)
+    return ivy.arange(start, stop=stop, step=step)
+
+
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def all(iterable):
+    return ivy.all(iterable)
+
+
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def any(iterable):
+    return ivy.any(iterable)
+
+
+@from_zero_dim_arrays_to_scalar
+def round(number, ndigits=None):
+    if not ndigits:
+        return ivy.round(number)
+    return ivy.round(number, decimals=ndigits)
+
+
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def min(*args, default=None, key=None):
+    # arguments are empty
+    if len(args) == 0:
+        # in this case default should be provided
+        if not default:
+            raise ValueError("default must be provided for empty input")
+        return default
+
+    # this means we deal with iterable rather than separate arguments
+    elif len(args) == 1 and not ivy.isscalar(args[0]):
+        # pass iterable to the same func
+        return builtins_frontend.min(*args[0], default=default, key=key)
+
+    # if keyfunc provided, map all args to it
+    if key:
+        mapped_args = ivy.map(key, constant=None, unique={"x": args}, mean=False)
+        idx = ivy.argmin(mapped_args)
+        # argmin always returns array, convert it to scalar
+        idx = ivy.to_scalar(idx)
+        return args[idx]
+
+    return ivy.min(args)
+
+
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def max(*args, default=None, key=None):
+    # arguments are empty
+    if len(args) == 0:
+        # in this case default should be provided
+        if not default:
+            raise ValueError("default must be provided for empty input")
+        return default
+
+    # this means we deal with iterable rather than separate arguments
+    elif len(args) == 1 and not ivy.isscalar(args[0]):
+        # pass iterable to the same func
+        return builtins_frontend.max(*args[0], default=default, key=key)
+
+    # if keyfunc provided, map all args to it
+    if key:
+        mapped_args = ivy.map(key, constant=None, unique={"x": args}, mean=False)
+        idx = ivy.argmax(mapped_args)
+        # argmin always returns array, convert it to scalar
+        idx = ivy.to_scalar(idx)
+        return args[idx]
+
+    return ivy.max(args)

ivy/functional/frontends/builtins/func_wrapper.py

@@ -0,0 +1,101 @@
+import functools
+from typing import Callable, Iterable
+from importlib import import_module
+
+import ivy
+
+
+def _to_ivy_array(x):
+    # if x is any frontend array including frontend list
+    # then extract the wrapped ivy array
+    if hasattr(x, "ivy_array"):
+        return x.ivy_array
+
+    # convert native arrays and lists to ivy arrays
+    elif isinstance(x, ivy.NativeArray):
+        return ivy.array(x)
+
+    return x
+
+
+def _infer_return_array(x: Iterable) -> Callable:
+    # get module path
+    module_path = x.__class__.__module__.split(".")
+
+    # if function's input is a scalar, list, or tuple
+    # convert to current backend's frontend array
+    if "builtins" in module_path:
+        cur_backend = ivy.current_backend_str()
+        module_str = cur_backend if len(cur_backend) != 0 else "numpy"
+
+    # in this case we're dealing with frontend array
+    # module's name is always at index 3 on the path
+    elif "ivy" in module_path:
+        module_str = module_path[3]
+
+    # native array, e.g. np.ndarray, torch.Tensor etc.
+    else:
+        module_str = module_path[0]
+        # replace jaxlib with jax to construct a valid path
+        module_str = "jax" if module_str == "jaxlib" else module_str
+
+    # import the module and get a corresponding frontend array
+    frontend_path = "ivy.functional.frontends." + module_str
+    module = import_module(frontend_path)
+    frontend_array = getattr(module, "_frontend_array")
+
+    return frontend_array
+
+
+def inputs_to_ivy_arrays(fn: Callable) -> Callable:
+    @functools.wraps(fn)
+    def _inputs_to_ivy_arrays_builtins(*args, **kwargs):
+        ivy_args = ivy.nested_map(args, _to_ivy_array, shallow=False)
+        ivy_kwargs = ivy.nested_map(kwargs, _to_ivy_array, shallow=False)
+
+        # array is the first argument given to a function
+        frontend_array = _infer_return_array(args[0]) if len(args) != 0 else None
+
+        return fn(*ivy_args, **ivy_kwargs), frontend_array
+
+    return _inputs_to_ivy_arrays_builtins
+
+
+def outputs_to_frontend_arrays(fn: Callable) -> Callable:
+    @functools.wraps(fn)
+    def _outputs_to_frontend_arrays(*args, **kwargs):
+        # update config for jax backend
+        if ivy.current_backend_str() == "jax":
+            import jax
+
+            jax.config.update("jax_enable_x64", True)
+
+        ret, frontend_array = fn(*args, **kwargs)
+
+        if isinstance(ret, (ivy.Array, ivy.NativeArray)):
+            return frontend_array(ret)
+        return ret
+
+    return _outputs_to_frontend_arrays
+
+
+def to_ivy_arrays_and_back(fn: Callable) -> Callable:
+    return outputs_to_frontend_arrays(inputs_to_ivy_arrays(fn))
+
+
+def from_zero_dim_arrays_to_scalar(fn: Callable) -> Callable:
+    @functools.wraps(fn)
+    def _from_zero_dim_arrays_to_scalar(*args, **kwargs):
+        ret = fn(*args, **kwargs)
+
+        if isinstance(ret, tuple):
+            return ivy.nested_map(
+                ret, lambda x: ivy.to_scalar(x) if len(x) == 0 else x, shallow=False
+            )
+
+        elif isinstance(ret, (int, float, bool, complex)) or len(ret) > 0:
+            return ret
+
+        return ivy.to_scalar(ret)
+
+    return _from_zero_dim_arrays_to_scalar

ivy/functional/frontends/builtins/math/__init__.py

@@ -0,0 +1,12 @@
+from . import power_and_logarithmic_functions
+from .power_and_logarithmic_functions import *
+from . import angular_conversion
+from .angular_conversion import *
+from . import special_functions
+from .special_functions import *
+from . import hyperbolic_functions
+from .hyperbolic_functions import *
+from . import trigonometric_functions
+from .trigonometric_functions import *
+from . import number_theoretic_and_representation_functions
+from .number_theoretic_and_representation_functions import *

ivy/functional/frontends/builtins/math/angular_conversion.py

@@ -0,0 +1,14 @@
+import ivy
+from ivy.functional.frontends.builtins.func_wrapper import (
+    from_zero_dim_arrays_to_scalar,
+)
+
+
+@from_zero_dim_arrays_to_scalar
+def radians(x):
+    return ivy.deg2rad(x)
+
+
+@from_zero_dim_arrays_to_scalar
+def degrees(x):
+    return ivy.rad2deg(x)

ivy/functional/frontends/builtins/math/hyperbolic_functions.py

@@ -0,0 +1,34 @@
+import ivy
+from ivy.functional.frontends.builtins.func_wrapper import (
+    from_zero_dim_arrays_to_scalar,
+)
+
+
+@from_zero_dim_arrays_to_scalar
+def acosh(x):
+    return ivy.acosh(x)
+
+
+@from_zero_dim_arrays_to_scalar
+def asinh(x):
+    return ivy.asinh(x)
+
+
+@from_zero_dim_arrays_to_scalar
+def atanh(x):
+    return ivy.atanh(x)
+
+
+@from_zero_dim_arrays_to_scalar
+def cosh(x):
+    return ivy.cosh(x)
+
+
+@from_zero_dim_arrays_to_scalar
+def sinh(x):
+    return ivy.sinh(x)
+
+
+@from_zero_dim_arrays_to_scalar
+def tanh(x):
+    return ivy.tanh(x)

ivy/functional/frontends/builtins/math/number_theoretic_and_representation_functions.py

@@ -0,0 +1,107 @@
+import ivy
+from ivy.functional.frontends.builtins.func_wrapper import (
+    to_ivy_arrays_and_back,
+    from_zero_dim_arrays_to_scalar,
+)
+
+
+@from_zero_dim_arrays_to_scalar
+def ceil(x):
+    return ivy.ceil(x).astype(int)
+
+
+@from_zero_dim_arrays_to_scalar
+def copysign(x, y):
+    return ivy.copysign(x, y)
+
+
+@from_zero_dim_arrays_to_scalar
+def fabs(x):
+    return ivy.abs(x).astype(float)
+
+
+@from_zero_dim_arrays_to_scalar
+def floor(x):
+    return ivy.floor(x).astype(int)
+
+
+@to_ivy_arrays_and_back
+def fmod(x, y):
+    return ivy.fmod(x, y).astype(float)
+
+
+@from_zero_dim_arrays_to_scalar
+def frexp(x):
+    return ivy.frexp(x)
+
+
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def fsum(x):
+    return ivy.sum(x).astype(float)
+
+
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def gcd(*integers):
+    if len(integers) == 0:
+        return 0
+    return ivy.gcd(*integers)
+
+
+@from_zero_dim_arrays_to_scalar
+def isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0):
+    return ivy.isclose(a, b, rtol=rel_tol, atol=abs_tol)
+
+
+@from_zero_dim_arrays_to_scalar
+def isfinite(x):
+    return ivy.isfinite(x)
+
+
+@from_zero_dim_arrays_to_scalar
+def isinf(x):
+    return ivy.isinf(x)
+
+
+@from_zero_dim_arrays_to_scalar
+def isnan(x):
+    return ivy.isnan(x)
+
+
+@from_zero_dim_arrays_to_scalar
+def isqrt(x):
+    return ivy.floor(ivy.sqrt(x)).astype(int)
+
+
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def lcm(*integers):
+    if len(integers) == 0:
+        return 1
+    return ivy.lcm(*integers)
+
+
+@from_zero_dim_arrays_to_scalar
+def ldexp(x, i):
+    return ivy.ldexp(x, i)
+
+
+@from_zero_dim_arrays_to_scalar
+def modf(x):
+    return ivy.modf(x)
+
+
+@from_zero_dim_arrays_to_scalar
+def nextafter(x, y):
+    return ivy.nextafter(x, y)
+
+
+@from_zero_dim_arrays_to_scalar
+def remainder(x, y):
+    return ivy.remainder(x, y).astype(float)
+
+
+@from_zero_dim_arrays_to_scalar
+def trunc(x):
+    return ivy.trunc(x)