squeeze and expand_dims funcs (#353)

* squeeze func impl and refactoring

Author: Alexander-Makaryev

dpnp/backend_manipulation.pyx

@@ -40,8 +40,10 @@ __all__ += [
     "dpnp_atleast_2d",
     "dpnp_atleast_3d",
     "dpnp_copyto",
+    "dpnp_expand_dims",
     "dpnp_repeat",
-    "dpnp_transpose"
+    "dpnp_transpose",
+    "dpnp_squeeze",
 ]
 
 
@@ -129,6 +131,38 @@ cpdef dparray dpnp_copyto(dparray dst, dparray src, where=True):
     return dst
 
 
+cpdef dparray dpnp_expand_dims(dparray in_array, axis):
+    axis_tuple = _object_to_tuple(axis)
+    result_ndim = len(axis_tuple) + in_array.ndim
+
+    if len(axis_tuple) == 0:
+        axis_ndim = 0
+    else:
+        axis_ndim = max(-min(0, min(axis_tuple)), max(0, max(axis_tuple))) + 1
+
+    axis_norm = _object_to_tuple(normalize_axis(axis_tuple, result_ndim))
+
+    if axis_ndim - len(axis_norm) > in_array.ndim:
+        checker_throw_axis_error("dpnp_expand_dims", "axis", axis, axis_ndim)
+
+    if len(axis_norm) > len(set(axis_norm)):
+        checker_throw_value_error("dpnp_expand_dims", "axis", axis, "no repeated axis")
+
+    shape_list = []
+    axis_idx = 0
+    for i in range(result_ndim):
+        if i in axis_norm:
+            shape_list.append(1)
+        else:
+            shape_list.append(in_array.shape[axis_idx])
+            axis_idx = axis_idx + 1
+
+    shape = _object_to_tuple(shape_list)
+    cdef dparray result = dpnp.copy(in_array).reshape(shape)
+
+    return result
+
+
 cpdef dparray dpnp_repeat(dparray array1, repeats, axes=None):
     cdef long new_size = array1.size * repeats
     cdef dparray result = dparray((new_size, ), dtype=array1.dtype)
@@ -181,3 +215,24 @@ cpdef dparray dpnp_transpose(dparray array1, axes=None):
     func(array1.get_data(), input_shape, result_shape, permute_axes, result.get_data(), array1.size)
 
     return result
+
+
+cpdef dparray dpnp_squeeze(dparray in_array, axis):
+    shape_list = []
+    if axis is None:
+        for i in range(in_array.ndim):
+            if in_array.shape[i] != 1:
+                shape_list.append(in_array.shape[i])
+    else:
+        axis_norm = _object_to_tuple(normalize_axis(_object_to_tuple(axis), in_array.ndim))
+        for i in range(in_array.ndim):
+            if i in axis_norm:
+                if in_array.shape[i] != 1:
+                    checker_throw_value_error("dpnp_squeeze", "axis", axis, "axis has size not equal to one")
+            else:
+                shape_list.append(in_array.shape[i])
+
+    shape = _object_to_tuple(shape_list)
+    cdef dparray result = dpnp.copy(in_array).reshape(shape)
+
+    return result

dpnp/dparray.pyx

@@ -573,6 +573,17 @@ cdef class dparray:
         """
         return std(self, axis, dtype, out, ddof, keepdims)
 
+    def squeeze(self, axis=None):
+        """
+        Remove single-dimensional entries from the shape of an array.
+
+        .. seealso::
+           :obj:`dpnp.squeeze` for full documentation
+
+        """
+
+        return squeeze(self, axis)
+
     def transpose(self, *axes):
         """ Returns a view of the array with axes permuted.
 

dpnp/dpnp_iface.py

@@ -61,7 +61,6 @@
 ]
 
 from dpnp.dpnp_iface_arraycreation import *
-from dpnp.dpnp_iface_arraymanipulation import *
 from dpnp.dpnp_iface_bitwise import *
 from dpnp.dpnp_iface_counting import *
 from dpnp.dpnp_iface_indexing import *
@@ -76,7 +75,6 @@
 from dpnp.dpnp_iface_trigonometric import *
 
 from dpnp.dpnp_iface_arraycreation import __all__ as __all__arraycreation
-from dpnp.dpnp_iface_arraymanipulation import __all__ as __all__arraymanipulation
 from dpnp.dpnp_iface_bitwise import __all__ as __all__bitwise
 from dpnp.dpnp_iface_counting import __all__ as __all__counting
 from dpnp.dpnp_iface_indexing import __all__ as __all__indexing
@@ -91,7 +89,6 @@
 from dpnp.dpnp_iface_trigonometric import __all__ as __all__trigonometric
 
 __all__ += __all__arraycreation
-__all__ += __all__arraymanipulation
 __all__ += __all__bitwise
 __all__ += __all__counting
 __all__ += __all__indexing

dpnp/dpnp_iface_arraymanipulation.py

@@ -47,22 +47,52 @@
 from dpnp.dparray import dparray
 from dpnp.dpnp_utils import *
 import dpnp
+from dpnp.dpnp_iface_arraycreation import array
 
 
 __all__ = [
+    "asfarray",
     "atleast_1d",
     "atleast_2d",
     "atleast_3d",
     "copyto",
+    "expand_dims",
     "moveaxis",
     "ravel",
     "repeat",
     "rollaxis",
+    "squeeze",
     "swapaxes",
     "transpose"
 ]
 
 
+def asfarray(a, dtype=numpy.float64):
+    """
+    Return an array converted to a float type.
+
+    For full documentation refer to :obj:`numpy.asfarray`.
+
+    Notes
+    -----
+    This function works exactly the same as :obj:`dpnp.array`.
+
+    """
+
+    if not use_origin_backend(a):
+        # behavior of original function: int types replaced with float64
+        if numpy.issubdtype(dtype, numpy.integer):
+            dtype = numpy.float64
+
+        # if type is the same then same object should be returned
+        if isinstance(a, dpnp.ndarray) and a.dtype == dtype:
+            return a
+
+        return array(a, dtype=dtype)
+
+    return call_origin(numpy.asfarray, a, dtype)
+
+
 def atleast_1d(*arys):
     """
     Convert inputs to arrays with at least one dimension.
@@ -193,6 +223,73 @@ def copyto(dst, src, casting='same_kind', where=True):
     return result
 
 
+def expand_dims(a, axis):
+    """
+    Expand the shape of an array.
+
+    Insert a new axis that will appear at the `axis` position in the expanded
+    array shape.
+
+    For full documentation refer to :obj:`numpy.expand_dims`.
+
+    See Also
+    --------
+    :obj:`dpnp.squeeze` : The inverse operation, removing singleton dimensions
+    :obj:`dpnp.reshape` : Insert, remove, and combine dimensions, and resize existing ones
+    :obj:`dpnp.indexing`, :obj:`dpnp.atleast_1d`, :obj:`dpnp.atleast_2d`, :obj:`dpnp.atleast_3d`
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> x = np.array([1, 2])
+    >>> x.shape
+    (2,)
+
+    The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``:
+
+    >>> y = np.expand_dims(x, axis=0)
+    >>> y
+    array([[1, 2]])
+    >>> y.shape
+    (1, 2)
+
+    The following is equivalent to ``x[:, np.newaxis]``:
+
+    >>> y = np.expand_dims(x, axis=1)
+    >>> y
+    array([[1],
+           [2]])
+    >>> y.shape
+    (2, 1)
+
+    ``axis`` may also be a tuple:
+
+    >>> y = np.expand_dims(x, axis=(0, 1))
+    >>> y
+    array([[[1, 2]]])
+
+    >>> y = np.expand_dims(x, axis=(2, 0))
+    >>> y
+    array([[[1],
+            [2]]])
+
+    Note that some examples may use ``None`` instead of ``np.newaxis``.  These
+    are the same objects:
+
+    >>> np.newaxis is None
+    True
+
+    """
+
+    if not use_origin_backend(a):
+        if not isinstance(a, dpnp.ndarray):
+            pass
+        else:
+            return dpnp_expand_dims(a, axis)
+
+    return call_origin(numpy.expand_dims, a, axis)
+
+
 def moveaxis(x1, source, destination):
     """
     Move axes of an array to new positions. Other axes remain in their original order.
@@ -397,6 +494,49 @@ def rollaxis(a, axis, start=0):
     return nd2dp_array(result)
 
 
+def squeeze(a, axis=None):
+    """
+    Remove single-dimensional entries from the shape of an array.
+
+    For full documentation refer to :obj:`numpy.squeeze`.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> x = np.array([[[0], [1], [2]]])
+    >>> x.shape
+    (1, 3, 1)
+    >>> np.squeeze(x).shape
+    (3,)
+    >>> np.squeeze(x, axis=0).shape
+    (3, 1)
+    >>> np.squeeze(x, axis=1).shape
+    Traceback (most recent call last):
+    ...
+    ValueError: cannot select an axis to squeeze out which has size not equal to one
+    >>> np.squeeze(x, axis=2).shape
+    (1, 3)
+    >>> x = np.array([[1234]])
+    >>> x.shape
+    (1, 1)
+    >>> np.squeeze(x)
+    array(1234)  # 0d array
+    >>> np.squeeze(x).shape
+    ()
+    >>> np.squeeze(x)[()]
+    1234
+
+    """
+
+    if not use_origin_backend(a):
+        if not isinstance(a, dpnp.ndarray):
+            pass
+        else:
+            return dpnp_squeeze(a, axis)
+
+    return call_origin(numpy.squeeze, a, axis)
+
+
 def swapaxes(x1, axis1, axis2):
     """
     Interchange two axes of an array.