Align in-place operation with explicit ufunc call

Author: antonwolfy

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -335,6 +335,20 @@ def __call__(
                 "as an argument, but both were provided."
             )
 
+        x1_usm = dpnp.get_usm_ndarray_or_scalar(x1)
+        x2_usm = dpnp.get_usm_ndarray_or_scalar(x2)
+        out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+        if (
+            isinstance(x1, dpnp_array)
+            and x1 is out
+            and order == "K"
+            and dtype is None
+        ):
+            # in-place operation
+            super()._inplace_op(x1_usm, x2_usm)
+            return x1
+
         if order is None:
             order = "K"
         elif order in "afkcAFKC":
@@ -344,9 +358,6 @@ def __call__(
                 "order must be one of 'C', 'F', 'A', or 'K' (got '{order}')"
             )
 
-        x1_usm = dpnp.get_usm_ndarray_or_scalar(x1)
-        x2_usm = dpnp.get_usm_ndarray_or_scalar(x2)
-
         if dtype is not None:
             if dpnp.isscalar(x1):
                 x1_usm = dpt.asarray(
@@ -368,20 +379,12 @@ def __call__(
                 x1_usm = dpt.astype(x1_usm, dtype, copy=False)
                 x2_usm = dpt.astype(x2_usm, dtype, copy=False)
 
-        out_usm = None if out is None else dpnp.get_usm_ndarray(out)
         res_usm = super().__call__(x1_usm, x2_usm, out=out_usm, order=order)
 
         if out is not None and isinstance(out, dpnp_array):
             return out
         return dpnp_array._create_from_usm_ndarray(res_usm)
 
-    def _inplace_op(self, x1, x2):
-        x1_usm = dpnp.get_usm_ndarray(x1)
-        x2_usm = dpnp.get_usm_ndarray_or_scalar(x2)
-
-        super()._inplace_op(x1_usm, x2_usm)
-        return x1
-
     def outer(
         self,
         x1,

dpnp/dpnp_array.py

@@ -347,22 +347,22 @@ def __gt__(self, other):
 
     def __iadd__(self, other):
         """Return ``self+=value``."""
-        dpnp.add._inplace_op(self, other)
+        dpnp.add(self, other, out=self)
         return self
 
     def __iand__(self, other):
         """Return ``self&=value``."""
-        dpnp.bitwise_and._inplace_op(self, other)
+        dpnp.bitwise_and(self, other, out=self)
         return self
 
     def __ifloordiv__(self, other):
         """Return ``self//=value``."""
-        dpnp.floor_divide._inplace_op(self, other)
+        dpnp.floor_divide(self, other, out=self)
         return self
 
     def __ilshift__(self, other):
         """Return ``self<<=value``."""
-        dpnp.left_shift._inplace_op(self, other)
+        dpnp.left_shift(self, other, out=self)
         return self
 
     def __imatmul__(self, other):
@@ -393,12 +393,12 @@ def __imatmul__(self, other):
 
     def __imod__(self, other):
         """Return ``self%=value``."""
-        dpnp.remainder._inplace_op(self, other)
+        dpnp.remainder(self, other, out=self)
         return self
 
     def __imul__(self, other):
         """Return ``self*=value``."""
-        dpnp.multiply._inplace_op(self, other)
+        dpnp.multiply(self, other, out=self)
         return self
 
     def __index__(self):
@@ -416,22 +416,22 @@ def __invert__(self):
 
     def __ior__(self, other):
         """Return ``self|=value``."""
-        dpnp.bitwise_or._inplace_op(self, other)
+        dpnp.bitwise_or(self, other, out=self)
         return self
 
     def __ipow__(self, other):
         """Return ``self**=value``."""
-        dpnp.power._inplace_op(self, other)
+        dpnp.power(self, other, out=self)
         return self
 
     def __irshift__(self, other):
         """Return ``self>>=value``."""
-        dpnp.right_shift._inplace_op(self, other)
+        dpnp.right_shift(self, other, out=self)
         return self
 
     def __isub__(self, other):
         """Return ``self-=value``."""
-        dpnp.subtract._inplace_op(self, other)
+        dpnp.subtract(self, other, out=self)
         return self
 
     def __iter__(self):
@@ -442,12 +442,12 @@ def __iter__(self):
 
     def __itruediv__(self, other):
         """Return ``self/=value``."""
-        dpnp.true_divide._inplace_op(self, other)
+        dpnp.true_divide(self, other, out=self)
         return self
 
     def __ixor__(self, other):
         """Return ``self^=value``."""
-        dpnp.bitwise_xor._inplace_op(self, other)
+        dpnp.bitwise_xor(self, other, out=self)
         return self
 
     def __le__(self, other):