Fix remaining dtype warnings in tests.tensor.test_basic

tests/tensor/utils.py

@@ -109,89 +109,6 @@ def eval_outputs(outputs, ops=(), mode=None):
     return variables
 
 
-def get_numeric_subclasses(cls=np.number, ignore=None):
-    """Return subclasses of `cls` in the numpy scalar hierarchy.
-
-    We only return subclasses that correspond to unique data types.  The
-    hierarchy can be seen here:
-    http://docs.scipy.org/doc/numpy/reference/arrays.scalars.html
-    """
-    if ignore is None:
-        ignore = []
-    rval = []
-    dtype = np.dtype(cls)
-    dtype_num = dtype.num
-    if dtype_num not in ignore:
-        # Safety check: we should be able to represent 0 with this data type.
-        np.array(0, dtype=dtype)
-        rval.append(cls)
-        ignore.append(dtype_num)
-    for sub_ in cls.__subclasses__():
-        rval += [c for c in get_numeric_subclasses(sub_, ignore=ignore)]
-    return rval
-
-
-def get_numeric_types(
-    with_int=True, with_float=True, with_complex=False, only_aesara_types=True
-):
-    """Return NumPy numeric data types.
-
-    Parameters
-    ----------
-    with_int
-        Whether to include integer types.
-    with_float
-        Whether to include floating point types.
-    with_complex
-        Whether to include complex types.
-    only_aesara_types
-        If ``True``, then numpy numeric data types that are not supported by
-        Aesara are ignored (i.e. those that are not declared in
-        ``scalar/basic.py``).
-
-    Returns
-    -------
-    A list of unique data type objects. Note that multiple data types may share
-    the same string representation, but can be differentiated through their
-    `num` attribute.
-
-    Note that when `only_aesara_types` is True we could simply return the list
-    of types defined in the `scalar` module. However with this function we can
-    test more unique dtype objects, and in the future we may use it to
-    automatically detect new data types introduced in numpy.
-    """
-    if only_aesara_types:
-        aesara_types = [d.dtype for d in aesara.scalar.all_types]
-    rval = []
-
-    def is_within(cls1, cls2):
-        # Return True if scalars defined from `cls1` are within the hierarchy
-        # starting from `cls2`.
-        # The third test below is to catch for instance the fact that
-        # one can use ``dtype=numpy.number`` and obtain a float64 scalar, even
-        # though `numpy.number` is not under `numpy.floating` in the class
-        # hierarchy.
-        return (
-            cls1 is cls2
-            or issubclass(cls1, cls2)
-            or isinstance(np.array([0], dtype=cls1)[0], cls2)
-        )
-
-    for cls in get_numeric_subclasses():
-        dtype = np.dtype(cls)
-        if (
-            (not with_complex and is_within(cls, np.complexfloating))
-            or (not with_int and is_within(cls, np.integer))
-            or (not with_float and is_within(cls, np.floating))
-            or (only_aesara_types and dtype not in aesara_types)
-        ):
-            # Ignore this class.
-            continue
-        rval.append([str(dtype), dtype, dtype.num])
-    # We sort it to be deterministic, then remove the string and num elements.
-    return [x[1] for x in sorted(rval, key=str)]
-
-
 def _numpy_checker(x, y):
     """Checks if `x.data` and `y.data` have the same contents.