Merge branch 'master' into impl_eigvalsh

Author: antonwolfy

SECURITY.md

@@ -0,0 +1,12 @@
+# Security Policy
+
+## Report a Vulnerability
+
+Please report security issues or vulnerabilities to the [Intel® Security Center].
+
+For more information on how Intel® works to resolve security issues, see
+[Vulnerability Handling Guidelines].
+
+[Intel® Security Center]:https://www.intel.com/content/www/us/en/security-center/default.html
+
+[Vulnerability Handling Guidelines]:https://www.intel.com/content/www/us/en/security-center/vulnerability-handling-guidelines.html

doc/reference/creation.rst

@@ -1,11 +1,11 @@
 .. _routines.creation:
 
-Array Creation Routines
+Array creation routines
 =======================
 
 .. https://docs.scipy.org/doc/numpy/reference/routines.array-creation.html
 
-Basic creation routines
+From shape or value
 -----------------------
 
 .. autosummary::
@@ -24,7 +24,7 @@ Basic creation routines
    dpnp.full_like
 
 
-Creation from other data
+From existing data
 ------------------------
 
 .. autosummary::
@@ -35,6 +35,7 @@ Creation from other data
    dpnp.asarray
    dpnp.asanyarray
    dpnp.ascontiguousarray
+   dpnp.astype
    dpnp.copy
    dpnp.frombuffer
    dpnp.from_dlpack
@@ -61,7 +62,7 @@ Numerical ranges
    dpnp.ogrid
 
 
-Matrix creation
+Building matrices
 ---------------
 
 .. autosummary::
@@ -82,5 +83,4 @@ The Matrix class
    :toctree: generated/
    :nosignatures:
 
-   dpnp.mat
    dpnp.bmat

dpnp/backend/include/dpnp_iface_fptr.hpp

@@ -174,8 +174,6 @@ enum class DPNPFuncName : size_t
     DPNP_FN_INV,         /**< Used in numpy.linalg.inv() impl  */
     DPNP_FN_INVERT,      /**< Used in numpy.invert() impl  */
     DPNP_FN_KRON,        /**< Used in numpy.kron() impl  */
-    DPNP_FN_KRON_EXT, /**< Used in numpy.kron() impl, requires extra parameters
-                       */
     DPNP_FN_LEFT_SHIFT,  /**< Used in numpy.left_shift() impl  */
     DPNP_FN_LOG,         /**< Used in numpy.log() impl  */
     DPNP_FN_LOG10,       /**< Used in numpy.log10() impl  */

dpnp/backend/kernels/dpnp_krnl_linalg.cpp

@@ -499,18 +499,6 @@ void (*dpnp_kron_default_c)(void *,
                             size_t) =
     dpnp_kron_c<_DataType1, _DataType2, _ResultType>;
 
-template <typename _DataType1, typename _DataType2, typename _ResultType>
-DPCTLSyclEventRef (*dpnp_kron_ext_c)(DPCTLSyclQueueRef,
-                                     void *,
-                                     void *,
-                                     void *,
-                                     shape_elem_type *,
-                                     shape_elem_type *,
-                                     shape_elem_type *,
-                                     size_t,
-                                     const DPCTLEventVectorRef) =
-    dpnp_kron_c<_DataType1, _DataType2, _ResultType>;
-
 template <typename _DataType>
 DPCTLSyclEventRef
     dpnp_matrix_rank_c(DPCTLSyclQueueRef q_ref,
@@ -890,67 +878,6 @@ void func_map_init_linalg_func(func_map_t &fmap)
         (void *)dpnp_kron_default_c<std::complex<double>, std::complex<double>,
                                     std::complex<double>>};
 
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_INT][eft_INT] = {
-        eft_INT, (void *)dpnp_kron_ext_c<int32_t, int32_t, int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_INT][eft_LNG] = {
-        eft_LNG, (void *)dpnp_kron_ext_c<int32_t, int64_t, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_INT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_kron_ext_c<int32_t, float, float>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_INT][eft_DBL] = {
-        eft_DBL, (void *)dpnp_kron_ext_c<int32_t, double, double>};
-    // fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_INT][eft_C128] = {
-    // eft_C128, (void*)dpnp_kron_ext_c<int32_t, std::complex<double>,
-    // std::complex<double>>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_LNG][eft_INT] = {
-        eft_LNG, (void *)dpnp_kron_ext_c<int64_t, int32_t, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_LNG][eft_LNG] = {
-        eft_LNG, (void *)dpnp_kron_ext_c<int64_t, int64_t, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_LNG][eft_FLT] = {
-        eft_FLT, (void *)dpnp_kron_ext_c<int64_t, float, float>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_LNG][eft_DBL] = {
-        eft_DBL, (void *)dpnp_kron_ext_c<int64_t, double, double>};
-    // fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_LNG][eft_C128] = {
-    // eft_C128, (void*)dpnp_kron_ext_c<int64_t, std::complex<double>,
-    // std::complex<double>>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_FLT][eft_INT] = {
-        eft_FLT, (void *)dpnp_kron_ext_c<float, int32_t, float>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_FLT][eft_LNG] = {
-        eft_FLT, (void *)dpnp_kron_ext_c<float, int64_t, float>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_kron_ext_c<float, float, float>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_FLT][eft_DBL] = {
-        eft_DBL, (void *)dpnp_kron_ext_c<float, double, double>};
-    // fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_FLT][eft_C128] = {
-    // eft_C128, (void*)dpnp_kron_ext_c<float, std::complex<double>,
-    // std::complex<double>>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_DBL][eft_INT] = {
-        eft_DBL, (void *)dpnp_kron_ext_c<double, int32_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_DBL][eft_LNG] = {
-        eft_DBL, (void *)dpnp_kron_ext_c<double, int64_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_DBL][eft_FLT] = {
-        eft_DBL, (void *)dpnp_kron_ext_c<double, float, double>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_kron_ext_c<double, double, double>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_DBL][eft_C128] = {
-        eft_C128, (void *)dpnp_kron_ext_c<double, std::complex<double>,
-                                          std::complex<double>>};
-    // fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_C128][eft_INT] = {
-    // eft_C128, (void*)dpnp_kron_ext_c<std::complex<double>, int32_t,
-    // std::complex<double>>};
-    // fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_C128][eft_LNG] = {
-    // eft_C128, (void*)dpnp_kron_ext_c<std::complex<double>, int64_t,
-    // std::complex<double>>};
-    // fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_C128][eft_FLT] = {
-    // eft_C128, (void*)dpnp_kron_ext_c<std::complex<double>, float,
-    // std::complex<double>>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_C128][eft_DBL] = {
-        eft_C128, (void *)dpnp_kron_ext_c<std::complex<double>, double,
-                                          std::complex<double>>};
-    fmap[DPNPFuncName::DPNP_FN_KRON_EXT][eft_C128][eft_C128] = {
-        eft_C128,
-        (void *)dpnp_kron_ext_c<std::complex<double>, std::complex<double>,
-                                std::complex<double>>};
-
     fmap[DPNPFuncName::DPNP_FN_MATRIX_RANK][eft_INT][eft_INT] = {
         eft_INT, (void *)dpnp_matrix_rank_default_c<int32_t>};
     fmap[DPNPFuncName::DPNP_FN_MATRIX_RANK][eft_LNG][eft_LNG] = {

dpnp/dpnp_algo/CMakeLists.txt

@@ -1,6 +1,5 @@
 
 set(dpnp_algo_pyx_deps
-  ${CMAKE_CURRENT_SOURCE_DIR}/dpnp_algo_linearalgebra.pxi
   ${CMAKE_CURRENT_SOURCE_DIR}/dpnp_algo_statistics.pxi
   ${CMAKE_CURRENT_SOURCE_DIR}/dpnp_algo_trigonometric.pxi
   ${CMAKE_CURRENT_SOURCE_DIR}/dpnp_algo_sorting.pxi

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -74,8 +74,6 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_FMOD_EXT
         DPNP_FN_FULL
         DPNP_FN_FULL_LIKE
-        DPNP_FN_KRON
-        DPNP_FN_KRON_EXT
         DPNP_FN_MAXIMUM
         DPNP_FN_MAXIMUM_EXT
         DPNP_FN_MEDIAN

dpnp/dpnp_algo/dpnp_algo.pyx

@@ -60,7 +60,6 @@ __all__ = [
 
 include "dpnp_algo_arraycreation.pxi"
 include "dpnp_algo_indexing.pxi"
-include "dpnp_algo_linearalgebra.pxi"
 include "dpnp_algo_logic.pxi"
 include "dpnp_algo_mathematical.pxi"
 include "dpnp_algo_sorting.pxi"

dpnp/dpnp_algo/dpnp_algo_linearalgebra.pxi

@@ -289,9 +289,9 @@ class dpnp_nd_grid:
     def __init__(
         self, sparse=False, device=None, usm_type="device", sycl_queue=None
     ):
-        dpu.validate_usm_type(usm_type, allow_none=False)
+        dpu.validate_usm_type(usm_type, allow_none=True)
         self.sparse = sparse
-        self.usm_type = usm_type
+        self.usm_type = "device" if usm_type is None else usm_type
         self.sycl_queue_normalized = dpnp.get_normalized_queue_device(
             sycl_queue=sycl_queue, device=device
         )

dpnp/dpnp_algo/dpnp_arraycreation.py

@@ -540,7 +540,7 @@ def astype(self, dtype, order="K", casting="unsafe", subok=True, copy=True):
             Array data type casting.
         dtype : dtype
             Target data type.
-        order : {'C', 'F', 'A', 'K'}
+        order : {"C", "F", "A", "K"}, optional
             Row-major (C-style) or column-major (Fortran-style) order.
             When ``order`` is 'A', it uses 'F' if ``a`` is column-major and uses 'C' otherwise.
             And when ``order`` is 'K', it keeps strides as closely as possible.

dpnp/dpnp_array.py

@@ -56,6 +56,7 @@
     "array_equal",
     "asnumpy",
     "astype",
+    "check_limitations",
     "check_supported_arrays_type",
     "convert_single_elem_array_to_scalar",
     "default_float_type",
@@ -232,6 +233,58 @@ def astype(x1, dtype, order="K", casting="unsafe", copy=True):
     return dpnp_array._create_from_usm_ndarray(array_obj)
 
 
+def check_limitations(
+    order=None, subok=False, like=None, initial=None, where=True
+):
+    """
+    Checking limitation kwargs for their supported values.
+
+    Parameter `order` is only supported with values ``"C"``, ``"F"``
+    and ``None``.
+    Parameter `subok` is only supported with default value ``False``.
+    Parameter `like` is only supported with default value ``None``.
+    Parameter `initial` is only supported with default value ``None``.
+    Parameter `where` is only supported with default value ``True``.
+
+    Raises
+    ------
+    NotImplementedError
+        If any input kwargs is of unsupported value.
+
+    """
+
+    if order in ("A", "a", "K", "k"):
+        raise NotImplementedError(
+            "Keyword argument `order` is supported only with "
+            f"values ``'C'`` and ``'F'``, but got {order}"
+        )
+    if order not in ("C", "c", "F", "f", None):
+        raise ValueError(
+            "Unrecognized `order` keyword value, expecting "
+            f"``'C'`` or ``'F'``, but got {order}"
+        )
+    if like is not None:
+        raise NotImplementedError(
+            "Keyword argument `like` is supported only with "
+            f"default value ``None``, but got {like}"
+        )
+    if subok is not False:
+        raise NotImplementedError(
+            "Keyword argument `subok` is supported only with "
+            f"default value ``False``, but got {subok}"
+        )
+    if initial is not None:
+        raise NotImplementedError(
+            "Keyword argument `initial` is only supported with "
+            f"default value ``None``, but got {initial}"
+        )
+    if where is not True:
+        raise NotImplementedError(
+            "Keyword argument `where` is supported only with "
+            f"default value ``True``, but got {where}"
+        )
+
+
 def check_supported_arrays_type(*arrays, scalar_type=False, all_scalars=False):
     """
     Return ``True`` if each array has either type of scalar,