ENH: introduce scalar type hierarchy

Try to duck-type NumPy, only without array scalars, so that

* dtype('float32').type --> np.float32

and

* np.float32(3) --> array(3.0, dtype='float32)

IOW, the attempt is to only have zero-dim arrays (we have them anyway)
and have them everywhere where NumPy creates a scalar.

Author: ev-br

torch_np/__init__.py

@@ -1,4 +1,5 @@
 from ._dtypes import *
+from ._scalar_types import *
 from ._wrapper import *
 from . import testing
 

torch_np/_dtypes.py

@@ -8,6 +8,8 @@
 import builtins
 import torch
 
+from . import _scalar_types
+
 # Define analogs of numpy dtypes supported by pytorch.
 
 class dtype:
@@ -22,6 +24,9 @@ def __init__(self, name):
             _name = typecode_chars_dict[name]
         elif name in dt_aliases_dict:
             _name = dt_aliases_dict[name]
+       # the check must come last, so that 'name' is not a string
+        elif issubclass(name, _scalar_types.generic):
+            _name = name.name
         else:
             raise TypeError(f"data type '{name}' not understood")
         self._name = _name
@@ -30,6 +35,10 @@ def __init__(self, name):
     def name(self):
         return self._name
 
+    @property
+    def type(self):
+        return _scalar_types._typemap[self._name]
+
     @property
     def typecode(self):
         return _typecodes_from_dtype_dict[self._name]
@@ -104,21 +113,6 @@ def __repr__(self):
 }
 
 
-float16 = dtype("float16")
-float32 = dtype("float32")
-float64 = dtype("float64")
-complex64 = dtype("complex64")
-complex128 = dtype("complex128")
-uint8 = dtype("uint8")
-int8 = dtype("int8")
-int16 = dtype("int16")
-int32 = dtype("int32")
-int64 = dtype("int64")
-bool = dtype("bool")
-
-intp = int64   # XXX
-int_ = int64
-
 # Map the torch-suppored subset dtypes to local analogs
 # "quantized" types not available in numpy, skip
 _dtype_from_torch_dict = {
@@ -217,5 +211,5 @@ def is_integer(dtyp):
 ########################## end autogenerated part
 
 
-__all__ = ['dtype_from_torch', 'dtype', 'typecodes'] + dt_names + ['intp', 'int_']
+__all__ = ['dtype_from_torch', 'dtype', 'typecodes']
 

torch_np/_scalar_types.py

@@ -0,0 +1,137 @@
+"""Replicate the NumPy scalar type hierarchy
+"""
+
+import abc
+import torch
+
+class generic(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def name(self):
+        return self.__class__.__name__
+
+    def __new__(self, value):
+        #
+        # Yes, a call to np.float32(4) produces a zero-dim array.
+        #
+        from . import _dtypes
+        from . import _ndarray
+
+        torch_dtype = _dtypes.torch_dtype_from(self.name)
+        tensor = torch.as_tensor(value, dtype=torch_dtype)
+        return _ndarray.ndarray._from_tensor_and_base(tensor, None)
+
+
+##### these are abstract types
+
+class number(generic):
+    pass
+
+
+class integer(generic):
+    pass
+
+
+class inexact(generic):
+    pass
+
+
+class signedinteger(generic):
+    pass
+
+
+class unsignedinteger(generic):
+    pass
+
+
+class inexact(generic):
+    pass
+
+
+class floating(generic):
+    pass
+
+
+class complexfloating(generic):
+    pass
+
+
+# ##### concrete types
+
+# signed integers
+
+class int8(signedinteger):
+    name = 'int8'
+
+
+class int16(signedinteger):
+    name = 'int16'
+
+
+class int32(signedinteger):
+    name = 'int32'
+
+
+class int64(signedinteger):
+    name = 'int64'
+
+
+# unsigned integers
+
+class uint8(unsignedinteger):
+    name = 'uint8'
+
+
+# floating point
+
+class float16(floating):
+    name = 'float16'
+
+
+class float32(floating):
+    name = 'float32'
+
+
+class float64(floating):
+    name = 'float64'
+
+
+class complex64(complexfloating):
+    name = 'complex64'
+
+
+class complex128(complexfloating):
+    name = 'complex128'
+
+
+class bool_(generic):
+    name = 'bool'
+
+
+# name aliases : FIXME (OS, bitness)
+intp = int64
+int_ = int64
+
+
+_typemap ={
+    'int8' : int8,
+    'int16' : int16,
+    'int32' : int32,
+    'int64' : int64,
+    'uint8' : uint8,
+    'float16': float16,
+    'float32': float32,
+    'float64': float64,
+    'complex64': complex64,
+    'complex128': complex128,
+    'bool': bool_
+}
+
+
+__all__ = list(_typemap.keys())
+__all__.remove('bool')
+
+__all__ += ['bool_', 'intp', 'int_']
+__all__ += ['generic', 'number',
+            'signedinteger', 'unsignedinteger',
+            'inexact', 'floating', 'complexfloating']