add_real_imag

.github/workflows/conda-package.yml

@@ -27,6 +27,7 @@ env:
       test_sycl_queue.py
       test_umath.py
       test_usm_type.py
+      third_party/cupy/core_tests/test_ndarray_complex_ops.py
       third_party/cupy/linalg_tests/test_product.py
       third_party/cupy/logic_tests/test_comparison.py
       third_party/cupy/logic_tests/test_truth.py

dpnp/dparray.pyx

@@ -30,7 +30,7 @@
 """Module DPArray
 
 This module contains Array class represents multi-dimensional array
-using USB interface for an Intel GPU device.
+using USM interface for an Intel GPU device.
 
 """
 
@@ -51,7 +51,7 @@ from dpnp.dpnp_iface import get_dpnp_descriptor as iface_get_dpnp_descriptor
 from dpnp.dpnp_iface import prod as iface_prod
 from dpnp.dpnp_iface import sum as iface_sum
 
-# It's prohibeted to use 'import *' from 'dpnp.dpnp_iface_arraycreation' module here,
+# It's prohibited to use 'import *' from 'dpnp.dpnp_iface_arraycreation' module here,
 # because module has 'array' function, but cython has already imported 'array' by default.
 # It would cause import collision. Thus instead import each function explicitly.
 from dpnp.dpnp_iface_arraycreation import (
@@ -196,7 +196,7 @@ cdef class dparray:
     """Multi-dimensional array using USM interface for an Intel GPU device.
 
     This class implements a subset of methods of :class:`numpy.ndarray`.
-    The difference is that this class allocates the array content useing
+    The difference is that this class allocates the array content using
     USM interface on the current GPU device.
 
     Args:

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -63,6 +63,7 @@
     "dpnp_floor_divide",
     "dpnp_greater",
     "dpnp_greater_equal",
+    "dpnp_imag",
     "dpnp_invert",
     "dpnp_isfinite",
     "dpnp_isinf",
@@ -80,6 +81,7 @@
     "dpnp_not_equal",
     "dpnp_power",
     "dpnp_proj",
+    "dpnp_real",
     "dpnp_remainder",
     "dpnp_right_shift",
     "dpnp_round",
@@ -1259,6 +1261,46 @@ def dpnp_greater_equal(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
+_imag_docstring = """
+imag(x, out=None, order="K")
+
+Computes imaginary part of each element `x_i` for input array `x`.
+
+Args:
+    x (dpnp.ndarray):
+        Input array, expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate.
+        Array have the correct shape and the expected data type.
+    order ("C","F","A","K", optional):
+        Memory layout of the newly output array, if parameter `out` is `None`.
+        Default: "K".
+Returns:
+    dpnp.ndarray:
+        An array containing the element-wise imaginary component of input.
+        If the input is a real-valued data type, the returned array has
+        the same data type. If the input is a complex floating-point
+        data type, the returned array has a floating-point data type
+        with the same floating-point precision as complex input.
+"""
+
+
+imag_func = UnaryElementwiseFunc(
+    "imag", ti._imag_result_type, ti._imag, _imag_docstring
+)
+
+
+def dpnp_imag(x, out=None, order="K"):
+    """Invokes imag() from dpctl.tensor implementation for imag() function."""
+
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = imag_func(x1_usm, out=out_usm, order=order)
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
 _invert_docstring = """
 invert(x, out=None, order='K')
 
@@ -2021,6 +2063,46 @@ def dpnp_proj(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
+_real_docstring = """
+real(x, out=None, order="K")
+
+Computes real part of each element `x_i` for input array `x`.
+
+Args:
+    x (dpnp.ndarray):
+        Input array, expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate.
+        Array have the correct shape and the expected data type.
+    order ("C","F","A","K", optional):
+        Memory layout of the newly output array, if parameter `out` is `None`.
+        Default: "K".
+Returns:
+    dpnp.ndarray:
+        An array containing the element-wise real component of input.
+        If the input is a real-valued data type, the returned array has
+        the same data type. If the input is a complex floating-point
+        data type, the returned array has a floating-point data type
+        with the same floating-point precision as complex input.
+"""
+
+
+real_func = UnaryElementwiseFunc(
+    "real", ti._real_result_type, ti._real, _real_docstring
+)
+
+
+def dpnp_real(x, out=None, order="K"):
+    """Invokes real() from dpctl.tensor implementation for real() function."""
+
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = real_func(x1_usm, out=out_usm, order=order)
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
 _remainder_docstring_ = """
 remainder(x1, x2, out=None, order='K')
 Calculates the remainder of division for each element `x1_i` of the input array

dpnp/dpnp_array.py

@@ -819,7 +819,44 @@ def flatten(self, order="C"):
         return new_arr
 
     # 'getfield',
-    # 'imag',
+
+    @property
+    def imag(self):
+        """
+        The imaginary part of the array.
+
+        For full documentation refer to :obj:`numpy.ndarray.imag`.
+
+        Examples
+        --------
+        >>> import dpnp as np
+        >>> x = np.sqrt(np.array([1+0j, 0+1j]))
+        >>> x.imag
+        array([0.        , 0.70710677])
+
+        """
+        return dpnp.imag(self)
+
+    @imag.setter
+    def imag(self, value):
+        """
+        Set the imaginary part of the array.
+
+        For full documentation refer to :obj:`numpy.ndarray.imag`.
+
+        Examples
+        --------
+        >>> import dpnp as np
+        >>> a = np.array([1+2j, 3+4j, 5+6j])
+        >>> a.imag = 9
+        >>> a
+        array([1.+9.j, 3.+9.j, 5.+9.j])
+
+        """
+        if dpnp.issubsctype(self.dtype, dpnp.complexfloating):
+            dpnp.copyto(self._array_obj.imag, value)
+        else:
+            raise TypeError("array does not have imaginary part to set")
 
     def item(self, id=None):
         """
@@ -975,7 +1012,42 @@ def put(self, indices, vals, /, *, axis=None, mode="wrap"):
         return dpnp.put(self, indices, vals, axis=axis, mode=mode)
 
     # 'ravel',
-    # 'real',
+
+    @property
+    def real(self):
+        """
+        The real part of the array.
+
+        For full documentation refer to :obj:`numpy.ndarray.real`.
+
+        Examples
+        --------
+        >>> import dpnp as np
+        >>> x = np.sqrt(np.array([1+0j, 0+1j]))
+        >>> x.real
+        array([1.        , 0.70710677])
+
+        """
+        return dpnp.real(self)
+
+    @real.setter
+    def real(self, value):
+        """
+        Set the real part of the array.
+
+        For full documentation refer to :obj:`numpy.ndarray.real`.
+
+        Examples
+        --------
+        >>> import dpnp as np
+        >>> a = np.array([1+2j, 3+4j, 5+6j])
+        >>> a.real = 9
+        >>> a
+        array([9.+2.j, 9.+4.j, 9.+6.j])
+
+        """
+        dpnp.copyto(self._array_obj.real, value)
+
     # 'repeat',
 
     def reshape(self, *sh, **kwargs):
@@ -1050,7 +1122,7 @@ def shape(self, newshape):
 
         """
 
-        dpnp.reshape(self, newshape=newshape)
+        self._array_obj.shape = newshape
 
     @property
     def size(self):