Add missing type aliases

Author: antonwolfy

dpnp/dpnp_algo/dpnp_algo.pyx

@@ -233,11 +233,11 @@ cpdef dpnp_queue_is_cpu():
 Internal functions
 """
 cdef DPNPFuncType dpnp_dtype_to_DPNPFuncType(dtype):
-    dt_c = numpy.dtype(dtype).char
-    kind = numpy.dtype(dtype).kind
+    dt_c = dpnp.dtype(dtype).char
+    kind = dpnp.dtype(dtype).kind
     if isinstance(kind, int):
         kind = chr(kind)
-    itemsize = numpy.dtype(dtype).itemsize
+    itemsize = dpnp.dtype(dtype).itemsize
 
     if dt_c == 'd':
         return DPNP_FT_DOUBLE
@@ -266,19 +266,19 @@ cdef dpnp_DPNPFuncType_to_dtype(size_t type):
     TODO needs to use DPNPFuncType here
     """
     if type == <size_t > DPNP_FT_DOUBLE:
-        return numpy.float64
+        return dpnp.float64
     elif type == <size_t > DPNP_FT_FLOAT:
-        return numpy.float32
+        return dpnp.float32
     elif type == <size_t > DPNP_FT_LONG:
-        return numpy.int64
+        return dpnp.int64
     elif type == <size_t > DPNP_FT_INT:
-        return numpy.int32
+        return dpnp.int32
     elif type == <size_t > DPNP_FT_CMPLX64:
-        return numpy.complex64
+        return dpnp.complex64
     elif type == <size_t > DPNP_FT_CMPLX128:
-        return numpy.complex128
+        return dpnp.complex128
     elif type == <size_t > DPNP_FT_BOOL:
-        return numpy.bool_
+        return dpnp.bool
     else:
         utils.checker_throw_type_error("dpnp_DPNPFuncType_to_dtype", type)
 

dpnp/dpnp_algo/dpnp_algo_statistics.pyx

@@ -1,7 +1,7 @@
 # cython: language_level=3
 # -*- coding: utf-8 -*-
 # *****************************************************************************
-# Copyright (c) 2016-2020, Intel Corporation
+# Copyright (c) 2016-2023, Intel Corporation
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -129,7 +129,7 @@ cpdef dpnp_average(utils.dpnp_descriptor x1):
     array_sum = dpnp_sum(x1).get_pyobj()
 
     """ Numpy interface inconsistency """
-    return_type = numpy.float32 if (x1.dtype == numpy.float32) else numpy.float64
+    return_type = dpnp.float32 if (x1.dtype == dpnp.float32) else dpnp.float64
 
     return (return_type(array_sum / x1.size))
 

dpnp/dpnp_array.py

@@ -527,7 +527,7 @@ def conj(self):
 
         """
 
-        if not numpy.issubsctype(self.dtype, numpy.complex_):
+        if not dpnp.issubsctype(self.dtype, dpnp.complex_):
             return self
         else:
             return dpnp.conjugate(self)
@@ -540,7 +540,7 @@ def conjugate(self):
 
         """
 
-        if not numpy.issubsctype(self.dtype, numpy.complex_):
+        if not dpnp.issubsctype(self.dtype, dpnp.complex_):
             return self
         else:
             return dpnp.conjugate(self)

dpnp/dpnp_iface_linearalgebra.py

@@ -2,7 +2,7 @@
 # distutils: language = c++
 # -*- coding: utf-8 -*-
 # *****************************************************************************
-# Copyright (c) 2016-2020, Intel Corporation
+# Copyright (c) 2016-2023, Intel Corporation
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -269,7 +269,7 @@ def matmul(x1, x2, out=None, **kwargs):
                 array2_size = x2_desc.size
                 cost_size = 4096  # 2D array shape(64, 64)
 
-                if ((x1_desc.dtype == numpy.float64) or (x1_desc.dtype == numpy.float32)):
+                if ((x1_desc.dtype == dpnp.float64) or (x1_desc.dtype == dpnp.float32)):
                     """
                     Floating point types are handled via original math library better than SYCL math library
                     """

dpnp/dpnp_iface_manipulation.py

@@ -2,7 +2,7 @@
 # distutils: language = c++
 # -*- coding: utf-8 -*-
 # *****************************************************************************
-# Copyright (c) 2016-2022, Intel Corporation
+# Copyright (c) 2016-2023, Intel Corporation
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -73,7 +73,7 @@
 ]
 
 
-def asfarray(x1, dtype=numpy.float64):
+def asfarray(x1, dtype=dpnp.float64):
     """
     Return an array converted to a float type.
 
@@ -88,8 +88,8 @@ def asfarray(x1, dtype=numpy.float64):
     x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
     if x1_desc:
         # behavior of original function: int types replaced with float64
-        if numpy.issubdtype(dtype, numpy.integer):
-            dtype = numpy.float64
+        if dpnp.issubdtype(dtype, dpnp.integer):
+            dtype = dpnp.float64
 
         # if type is the same then same object should be returned
         if x1_desc.dtype == dtype:

dpnp/dpnp_iface_types.py

@@ -40,39 +40,73 @@
 __all__ = [
     "bool",
     "bool_",
+    "cdouble",
+    "complex_",
     "complex128",
     "complex64",
+    "complexfloating",
+    "cfloat",
+    "csingle",
+    "double",
     "dtype",
     "float",
+    "float_",
     "float16",
     "float32",
     "float64",
+    "floating",
+    "inexact",
     "int",
+    "int_",
     "int32",
     "int64",
     "integer",
+    "intc",
     "isscalar",
+    "issubdtype",
+    "issubsctype",
     "is_type_supported",
     "longcomplex",
     "nan",
     "newaxis",
+    "number",
+    "object_",
+    "signedinteger",
+    "single",
+    "singlecomplex",
     "void"
 ]
 
 bool = numpy.bool_
 bool_ = numpy.bool_
+cdouble = numpy.cdouble
+complex_ = numpy.complex_
 complex128 = numpy.complex128
 complex64 = numpy.complex64
+complexfloating = numpy.complexfloating
+cfloat = numpy.cfloat
+csingle = numpy.csingle
+double = numpy.double
 dtype = numpy.dtype
+float = numpy.float_
+float_ = numpy.float_
 float16 = numpy.float16
 float32 = numpy.float32
 float64 = numpy.float64
-float = numpy.float_
+floating = numpy.floating
+inexact = numpy.inexact
+int = numpy.int_
+int_ = numpy.int_
 int32 = numpy.int32
 int64 = numpy.int64
 integer = numpy.integer
-int = numpy.int_
+intc = numpy.intc
 longcomplex = numpy.longcomplex
+number = numpy.number
+object_ = numpy.object_
+signedinteger = numpy.signedinteger
+single = numpy.single
+singlecomplex = numpy.singlecomplex
 
 
 def isscalar(obj):
@@ -85,6 +119,28 @@ def isscalar(obj):
     return numpy.isscalar(obj)
 
 
+def issubdtype(arg1, arg2):
+    """
+    Returns True if first argument is a typecode lower/equal in type hierarchy.
+
+    For full documentation refer to :obj:`numpy.issubdtype`.
+
+    """
+
+    return numpy.issubdtype(arg1, arg2)
+
+
+def issubsctype(arg1, arg2):
+    """
+    Determine if the first argument is a subclass of the second argument.
+
+    For full documentation refer to :obj:`numpy.issubsctype`.
+
+    """
+
+    return numpy.issubsctype(arg1, arg2)
+
+
 nan = numpy.nan
 newaxis = None
 void = numpy.void

dpnp/dpnp_utils/dpnp_algo_utils.pyx

@@ -268,18 +268,18 @@ def map_dtype_to_device(dtype, device):
     Map an input ``dtype`` with type ``device`` may use
     """
 
-    dtype = numpy.dtype(dtype)
+    dtype = dpnp.dtype(dtype)
     if not hasattr(dtype, 'char'):
         raise TypeError(f"Invalid type of input dtype={dtype}")
     elif not isinstance(device, dpctl.SyclDevice):
         raise TypeError(f"Invalid type of input device={device}")
 
     dtc = dtype.char
-    if dtc == "?" or numpy.issubdtype(dtype, numpy.integer):
+    if dtc == "?" or dpnp.issubdtype(dtype, dpnp.integer):
         # bool or integer type
         return dtype
 
-    if numpy.issubdtype(dtype, numpy.floating):
+    if dpnp.issubdtype(dtype, dpnp.floating):
         if dtc == "f":
             # float32 type
             return dtype
@@ -294,7 +294,7 @@ def map_dtype_to_device(dtype, device):
         # float32 is default floating type
         return dpnp.dtype("f4")
 
-    if numpy.issubdtype(dtype, numpy.complexfloating):
+    if dpnp.issubdtype(dtype, dpnp.complexfloating):
         if dtc == "F":
             # complex64 type
             return dtype
@@ -418,14 +418,14 @@ cdef tuple get_shape_dtype(object input_obj):
 
             # shape and dtype does not match with siblings.
             if ((return_shape != elem_shape) or (return_dtype != elem_dtype)):
-                return (elem_shape, numpy.dtype(numpy.object_))
+                return (elem_shape, dpnp.dtype(dpnp.object_))
 
         list_shape.push_back(len(input_obj))
         list_shape.insert(list_shape.end(), return_shape.begin(), return_shape.end())
         return (list_shape, return_dtype)
 
     # assume scalar or object
-    return (return_shape, numpy.dtype(type(input_obj)))
+    return (return_shape, dpnp.dtype(type(input_obj)))
 
 
 cpdef find_common_type(object x1_obj, object x2_obj):

dpnp/linalg/dpnp_algo_linalg.pyx

@@ -1,7 +1,7 @@
 # cython: language_level=3
 # -*- coding: utf-8 -*-
 # *****************************************************************************
-# Copyright (c) 2016-2022, Intel Corporation
+# Copyright (c) 2016-2023, Intel Corporation
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -342,13 +342,13 @@ cpdef object dpnp_norm(object input, ord=None, axis=None):
     cdef long size_input = input.size
     cdef shape_type_c shape_input = input.shape
 
-    if input.dtype == numpy.float32:
-        res_type = numpy.float32
+    if input.dtype == dpnp.float32:
+        res_type = dpnp.float32
     else:
-        res_type = numpy.float64
+        res_type = dpnp.float64
 
     if size_input == 0:
-        return dpnp.array([numpy.nan], dtype=res_type)
+        return dpnp.array([dpnp.nan], dtype=res_type)
 
     if isinstance(axis, int):
         axis_ = tuple([axis])