Implement call of arange() function from dpctl.tensor

Author: antonwolfy

dpnp/dpnp_container.py

@@ -34,18 +34,43 @@
 """
 
 
+import dpctl.utils as dpu
 import dpctl.tensor as dpt
 
 from dpnp.dpnp_array import dpnp_array
 import dpnp
 
 
 __all__ = [
+    "arange",
     "asarray",
     "empty",
 ]
 
 
+def arange(start,
+           /,
+           stop=None,
+           step=1,
+           *,
+           dtype=None,
+           device=None,
+           usm_type="device",
+           sycl_queue=None):
+    """Validate input parameters before passing them into `dpctl.tensor` module"""
+    dpu.validate_usm_type(usm_type, allow_none=False)
+    sycl_queue_normalized = dpnp.normalize_queue_device(sycl_queue=sycl_queue, device=device)
+
+    array_obj = dpt.arange(start,
+                           stop=stop,
+                           step=step,
+                           dtype=dtype,
+                           usm_type=usm_type,
+                           sycl_queue=sycl_queue_normalized)
+
+    return dpnp_array(array_obj.shape, buffer=array_obj)
+
+
 def asarray(x1,
             dtype=None,
             copy=False,

dpnp/dpnp_iface_arraycreation.py

@@ -2,7 +2,7 @@
 # distutils: language = c++
 # -*- coding: utf-8 -*-
 # *****************************************************************************
-# Copyright (c) 2016-2020, Intel Corporation
+# Copyright (c) 2016-2022, Intel Corporation
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -90,7 +90,16 @@
 ]
 
 
-def arange(start, stop=None, step=1, dtype=None):
+def arange(start,
+           /,
+           stop=None,
+           step=1,
+           *,
+           dtype=None,
+           like=None,
+           device=None,
+           usm_type="device",
+           sycl_queue=None):
     """
     Returns an array with evenly spaced values within a given interval.
 
@@ -99,12 +108,11 @@ def arange(start, stop=None, step=1, dtype=None):
     Returns
     -------
     arange : :obj:`dpnp.ndarray`
-        The 1-D array of range values.
+        The 1-D array containing evenly spaced values.
 
     Limitations
     -----------
-    Parameter ``start`` is supported as integer only.
-    Parameters ``stop`` and ``step`` are supported as either integer or ``None``.
+    Parameter ``like`` is supported only with default value ``None``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
@@ -113,7 +121,6 @@ def arange(start, stop=None, step=1, dtype=None):
 
     Examples
     --------
-
     >>> import dpnp as np
     >>> [i for i in np.arange(3)]
     [0, 1, 2]
@@ -123,34 +130,15 @@ def arange(start, stop=None, step=1, dtype=None):
     [3, 5]
 
     """
-    if not use_origin_backend():
-        if not isinstance(start, int):
-            pass
-        elif (stop is not None) and (not isinstance(stop, int)):
-            pass
-        elif (step is not None) and (not isinstance(step, int)):
-            pass
-        # TODO: modify native implementation to accept negative values
-        elif (step is not None) and (step < 0):
-            pass
-        elif (start is not None) and (start < 0):
-            pass
-        elif (start is not None) and (stop is not None) and (start > stop):
-            pass
-        elif (dtype is not None) and (dtype not in [dpnp.int32, dpnp.int64, dpnp.float32, dpnp.float64]):
-            pass
-        else:
-            if dtype is None:
-                dtype = numpy.int64
-
-            if stop is None:
-                stop = start
-                start = 0
-
-            if step is None:
-                step = 1
 
-            return dpnp_arange(start, stop, step, dtype).get_pyobj()
+    if like is None:
+        return dpnp_container.arange(start,
+                                     stop=stop,
+                                     step=step,
+                                     dtype=dtype,
+                                     device=device,
+                                     usm_type=usm_type,
+                                     sycl_queue=sycl_queue)
 
     return call_origin(numpy.arange, start, stop=stop, step=step, dtype=dtype)