Unskip tests (#659)

* unskip 308 tests

Author: Rubtsowa

dpnp/dparray.pyx

@@ -762,7 +762,7 @@ cdef class dparray:
     def __truediv__(self, other):
         return divide(self, other)
 
-    cpdef dparray astype(self, dtype, order='K', casting=None, subok=None, copy=True):
+    cpdef dparray astype(self, dtype, order='K', casting='unsafe', subok=True, copy=True):
         """Copy the array with data type casting.
 
         Args:
@@ -784,19 +784,22 @@ cdef class dparray:
 
         """
 
-        if casting is not None:
-            utils.checker_throw_value_error("astype", "casting", casting, None)
-
-        if subok is not None:
-            utils.checker_throw_value_error("astype", "subok", subok, None)
-
-        if copy is not True:
-            utils.checker_throw_value_error("astype", "copy", copy, True)
+        if casting is not 'unsafe':
+            pass
+        elif subok is not True:
+            pass
+        elif copy is not True:
+            pass
+        elif order is not 'K':
+            pass
+        elif self.dtype == numpy.complex128:
+            pass
+        else:
+            return dpnp_astype(self, dtype)
 
-        if order is not 'K':
-            utils.checker_throw_value_error("astype", "order", order, 'K')
+        result = utils.dp2nd_array(self).astype(dtype=dtype, order=order, casting=casting, subok=subok, copy=copy)
 
-        return dpnp_astype(self, dtype)
+        return utils.nd2dp_array(result)
 
     def conj(self):
         """
@@ -854,12 +857,12 @@ cdef class dparray:
 
         return iface_sum(*args, **kwargs)
 
-    def max(self, axis=None):
+    def max(self, axis=None, out=None, keepdims=numpy._NoValue, initial=numpy._NoValue, where=numpy._NoValue):
         """
         Return the maximum along an axis.
         """
 
-        return max(self, axis)
+        return max(self, axis, out, keepdims, initial, where)
 
     def mean(self, axis=None):
         """
@@ -868,12 +871,12 @@ cdef class dparray:
 
         return mean(self, axis)
 
-    def min(self, axis=None):
+    def min(self, axis=None, out=None, keepdims=numpy._NoValue, initial=numpy._NoValue, where=numpy._NoValue):
         """
         Return the minimum along a given axis.
         """
 
-        return min(self, axis)
+        return min(self, axis, out, keepdims, initial, where)
 
     """
     -------------------------------------------------------------------------
@@ -887,6 +890,12 @@ cdef class dparray:
         """
         return choose(input, choices, out, mode)
 
+    def diagonal(input, offset=0, axis1=0, axis2=1):
+        """
+        Return specified diagonals.
+        """
+        return diagonal(input, offset, axis1, axis2)
+
     def take(self, indices, axis=None, out=None, mode='raise'):
         """
         Take elements from an array.

dpnp/dpnp_iface_statistics.py

@@ -276,7 +276,7 @@ def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=N
     return call_origin(numpy.cov, m, y, rowvar, bias, ddof, fweights, aweights)
 
 
-def max(input, axis=None, out=None):
+def max(input, axis=None, out=None, keepdims=numpy._NoValue, initial=numpy._NoValue, where=numpy._NoValue):
     """
     Return the maximum of an array or maximum along an axis.
 
@@ -300,33 +300,27 @@ def max(input, axis=None, out=None):
 
     """
 
-    dim_input = input.ndim
-
-    is_input_dparray = isinstance(input, dparray)
-
-    if not use_origin_backend(input) and is_input_dparray:
-        if out is not None:
-            checker_throw_value_error("max", "out", type(out), None)
-
-        result = dpnp_max(input, axis=axis)
-
-        # scalar returned
-        if result.shape == (1,):
-            return result.dtype.type(result[0])
-
-        return result
+    if not use_origin_backend(input):
+        if not isinstance(input, dparray):
+            pass
+        elif out is not None:
+            pass
+        elif keepdims is not numpy._NoValue:
+            pass
+        elif initial is not numpy._NoValue:
+            pass
+        elif where is not numpy._NoValue:
+            pass
+        else:
+            result = dpnp_max(input, axis=axis)
 
-    input1 = dpnp.asnumpy(input) if is_input_dparray else input
+            # scalar returned
+            if result.shape == (1,):
+                return result.dtype.type(result[0])
 
-    # TODO need to put dparray memory into NumPy call
-    result_numpy = numpy.max(input1, axis=axis)
-    result = result_numpy
-    if isinstance(result, numpy.ndarray):
-        result = dparray(result_numpy.shape, dtype=result_numpy.dtype)
-        for i in range(result.size):
-            result._setitem_scalar(i, result_numpy.item(i))
+            return result
 
-    return result
+    return call_origin(numpy.max, input, axis, out, keepdims, initial, where)
 
 
 def mean(a, axis=None, **kwargs):
@@ -433,7 +427,7 @@ def median(a, axis=None, out=None, overwrite_input=False, keepdims=False):
     return call_origin(numpy.median, a, axis, out, overwrite_input, keepdims)
 
 
-def min(input, axis=None, out=None):
+def min(input, axis=None, out=None, keepdims=numpy._NoValue, initial=numpy._NoValue, where=numpy._NoValue):
     """
     Return the minimum along a given axis.
 
@@ -457,31 +451,27 @@ def min(input, axis=None, out=None):
 
     """
 
-    is_input_dparray = isinstance(input, dparray)
-
-    if not use_origin_backend(input) and is_input_dparray:
-        if out is not None:
-            checker_throw_value_error("min", "out", type(out), None)
-
-        result = dpnp_min(input, axis=axis)
-
-        # scalar returned
-        if result.shape == (1,):
-            return result.dtype.type(result[0])
-
-        return result
+    if not use_origin_backend(input):
+        if not isinstance(input, dparray):
+            pass
+        elif out is not None:
+            pass
+        elif keepdims is not numpy._NoValue:
+            pass
+        elif initial is not numpy._NoValue:
+            pass
+        elif where is not numpy._NoValue:
+            pass
+        else:
+            result = dpnp_min(input, axis=axis)
 
-    input1 = dpnp.asnumpy(input) if is_input_dparray else input
+            # scalar returned
+            if result.shape == (1,):
+                return result.dtype.type(result[0])
 
-    # TODO need to put dparray memory into NumPy call
-    result_numpy = numpy.min(input1, axis=axis)
-    result = result_numpy
-    if isinstance(result, numpy.ndarray):
-        result = dparray(result_numpy.shape, dtype=result_numpy.dtype)
-        for i in range(result.size):
-            result._setitem_scalar(i, result_numpy.item(i))
+            return result
 
-    return result
+    return call_origin(numpy.min, input, axis, out, keepdims, initial, where)
 
 
 def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=numpy._NoValue):