Merge remote-tracking branch 'upstream/master' into gold/2021

Author: ndgrigorian

dpctl/tensor/__init__.py

@@ -94,13 +94,28 @@
 from ._elementwise_funcs import (
     abs,
     add,
+    conj,
     cos,
     divide,
     equal,
+    exp,
+    expm1,
+    floor_divide,
+    greater,
+    greater_equal,
+    imag,
     isfinite,
     isinf,
     isnan,
+    less,
+    less_equal,
+    log,
+    log1p,
     multiply,
+    not_equal,
+    proj,
+    real,
+    sin,
     sqrt,
     subtract,
 )
@@ -183,14 +198,29 @@
     "inf",
     "abs",
     "add",
+    "conj",
     "cos",
+    "exp",
+    "expm1",
+    "greater",
+    "greater_equal",
+    "imag",
     "isinf",
     "isnan",
     "isfinite",
+    "less",
+    "less_equal",
+    "log",
+    "log1p",
+    "proj",
+    "real",
+    "sin",
     "sqrt",
     "divide",
     "multiply",
     "subtract",
     "equal",
+    "not_equal",
     "sum",
+    "floor_divide",
 ]

dpctl/tensor/_elementwise_common.py

@@ -162,9 +162,18 @@ def get(self):
         return self.o_
 
 
-class WeakInexactType:
-    """Python type representing type of Python real- or
-    complex-valued floating point objects"""
+class WeakFloatingType:
+    """Python type representing type of Python floating point objects"""
+
+    def __init__(self, o):
+        self.o_ = o
+
+    def get(self):
+        return self.o_
+
+
+class WeakComplexType:
+    """Python type representing type of Python complex floating point objects"""
 
     def __init__(self, o):
         self.o_ = o
@@ -189,14 +198,17 @@ def _get_dtype(o, dev):
         return WeakBooleanType(o)
     if isinstance(o, int):
         return WeakIntegralType(o)
-    if isinstance(o, (float, complex)):
-        return WeakInexactType(o)
+    if isinstance(o, float):
+        return WeakFloatingType(o)
+    if isinstance(o, complex):
+        return WeakComplexType(o)
     return np.object_
 
 
 def _validate_dtype(dt) -> bool:
     return isinstance(
-        dt, (WeakBooleanType, WeakInexactType, WeakIntegralType)
+        dt,
+        (WeakBooleanType, WeakIntegralType, WeakFloatingType, WeakComplexType),
     ) or (
         isinstance(dt, dpt.dtype)
         and dt
@@ -220,22 +232,24 @@ def _validate_dtype(dt) -> bool:
 
 
 def _weak_type_num_kind(o):
-    _map = {"?": 0, "i": 1, "f": 2}
+    _map = {"?": 0, "i": 1, "f": 2, "c": 3}
     if isinstance(o, WeakBooleanType):
         return _map["?"]
     if isinstance(o, WeakIntegralType):
         return _map["i"]
-    if isinstance(o, WeakInexactType):
+    if isinstance(o, WeakFloatingType):
         return _map["f"]
+    if isinstance(o, WeakComplexType):
+        return _map["c"]
     raise TypeError(
         f"Unexpected type {o} while expecting "
-        "`WeakBooleanType`, `WeakIntegralType`, or "
-        "`WeakInexactType`."
+        "`WeakBooleanType`, `WeakIntegralType`,"
+        "`WeakFloatingType`, or `WeakComplexType`."
     )
 
 
 def _strong_dtype_num_kind(o):
-    _map = {"b": 0, "i": 1, "u": 1, "f": 2, "c": 2}
+    _map = {"b": 0, "i": 1, "u": 1, "f": 2, "c": 3}
     if not isinstance(o, dpt.dtype):
         raise TypeError
     k = o.kind
@@ -247,10 +261,17 @@ def _strong_dtype_num_kind(o):
 def _resolve_weak_types(o1_dtype, o2_dtype, dev):
     "Resolves weak data type per NEP-0050"
     if isinstance(
-        o1_dtype, (WeakBooleanType, WeakInexactType, WeakIntegralType)
+        o1_dtype,
+        (WeakBooleanType, WeakIntegralType, WeakFloatingType, WeakComplexType),
     ):
         if isinstance(
-            o2_dtype, (WeakBooleanType, WeakInexactType, WeakIntegralType)
+            o2_dtype,
+            (
+                WeakBooleanType,
+                WeakIntegralType,
+                WeakFloatingType,
+                WeakComplexType,
+            ),
         ):
             raise ValueError
         o1_kind_num = _weak_type_num_kind(o1_dtype)
@@ -260,7 +281,9 @@ def _resolve_weak_types(o1_dtype, o2_dtype, dev):
                 return dpt.bool, o2_dtype
             if isinstance(o1_dtype, WeakIntegralType):
                 return dpt.int64, o2_dtype
-            if isinstance(o1_dtype.get(), complex):
+            if isinstance(o1_dtype, WeakComplexType):
+                if o2_dtype is dpt.float16 or o2_dtype is dpt.float32:
+                    return dpt.complex64, o2_dtype
                 return (
                     _to_device_supported_dtype(dpt.complex128, dev),
                     o2_dtype,
@@ -269,7 +292,8 @@ def _resolve_weak_types(o1_dtype, o2_dtype, dev):
         else:
             return o2_dtype, o2_dtype
     elif isinstance(
-        o2_dtype, (WeakBooleanType, WeakInexactType, WeakIntegralType)
+        o2_dtype,
+        (WeakBooleanType, WeakIntegralType, WeakFloatingType, WeakComplexType),
     ):
         o1_kind_num = _strong_dtype_num_kind(o1_dtype)
         o2_kind_num = _weak_type_num_kind(o2_dtype)
@@ -278,7 +302,9 @@ def _resolve_weak_types(o1_dtype, o2_dtype, dev):
                 return o1_dtype, dpt.bool
             if isinstance(o2_dtype, WeakIntegralType):
                 return o1_dtype, dpt.int64
-            if isinstance(o2_dtype.get(), complex):
+            if isinstance(o2_dtype, WeakComplexType):
+                if o1_dtype is dpt.float16 or o1_dtype is dpt.float32:
+                    return o1_dtype, dpt.complex64
                 return o1_dtype, _to_device_supported_dtype(dpt.complex128, dev)
             return (
                 o1_dtype,
@@ -433,7 +459,7 @@ def __call__(self, o1, o2, out=None, order="K"):
             if out is None:
                 if order == "K":
                     out = _empty_like_pair_orderK(
-                        src1, src2, res_dt, res_usm_type, exec_q
+                        src1, src2, res_dt, res_shape, res_usm_type, exec_q
                     )
                 else:
                     if order == "A":
@@ -482,7 +508,7 @@ def __call__(self, o1, o2, out=None, order="K"):
             if out is None:
                 if order == "K":
                     out = _empty_like_pair_orderK(
-                        src1, buf2, res_dt, res_usm_type, exec_q
+                        src1, buf2, res_dt, res_shape, res_usm_type, exec_q
                     )
                 else:
                     out = dpt.empty(
@@ -524,7 +550,7 @@ def __call__(self, o1, o2, out=None, order="K"):
             if out is None:
                 if order == "K":
                     out = _empty_like_pair_orderK(
-                        buf1, src2, res_dt, res_usm_type, exec_q
+                        buf1, src2, res_dt, res_shape, res_usm_type, exec_q
                     )
                 else:
                     out = dpt.empty(
@@ -578,7 +604,7 @@ def __call__(self, o1, o2, out=None, order="K"):
         if out is None:
             if order == "K":
                 out = _empty_like_pair_orderK(
-                    buf1, buf2, res_dt, res_usm_type, exec_q
+                    buf1, buf2, res_dt, res_shape, res_usm_type, exec_q
                 )
             else:
                 out = dpt.empty(