Fix and expand tests for bincount

theano/tensor/extra_ops.py

+import sys
+
 import numpy as np
 import numpy
 
 import theano
 import basic
-from theano import gof, tensor, function, scalar
+from theano import gof, tensor, scalar
 from theano.sandbox.linalg.ops import diag
 
 
@@ -132,6 +134,21 @@ class BinCountOp(theano.Op):
 
         if x.dtype not in BinCountOp.compatible_type:
             raise TypeError("Inputs dtype must be an integer.")
+
+        # Some dtypes are not supported by numpy's implementation of bincount.
+        # Until another one is available, we should fail at graph construction
+        # time, not wait for execution.
+        int_bitwidth = theano.gof.cmodule.python_int_bitwidth()
+        if int_bitwidth == 64:
+            numpy_unsupported_dtypes = ('uint64',)
+        if int_bitwidth == 32:
+            numpy_unsupported_dtypes = ('uint32', 'int64', 'uint64')
+
+        if x.dtype in numpy_unsupported_dtypes:
+            raise TypeError(
+                    ("Input dtypes %s are not supported by numpy.bincount, "
+                    % numpy_unsupported_dtypes), x.dtype)
+
         if x.ndim != 1:
             raise TypeError("Inputs must be of dimension 1.")
 

theano/tensor/opt.py

@@ -970,7 +970,7 @@ class ShapeFeature(object):
                 # but this works with `local_useless_subtensor`, so for now we
                 # keep it this way. See #266 for a better long-term fix.
                 if getattr(d, 'dtype', 'int64') != 'int64':
-                    assert d.dtype in theano.tensor.int_dtypes
+                    assert d.dtype in theano.tensor.int_dtypes, d.dtype
                     new_shape += sh[len(new_shape):i + 1]
                     new_shape[i] = theano.tensor.cast(d, 'int64')
             if new_shape:

theano/tensor/tests/test_extra_ops.py

+import sys
+
 import numpy as np
 import numpy
 
@@ -15,44 +17,82 @@ class TestBinCountOp(utt.InferShapeTester):
         self.op = BinCountOp()
 
     def test_bincountOp(self):
-        x = T.lvector('x')
         w = T.vector('w')
-        a = np.random.random_integers(50, size=(25))
-        weights = np.random.random((25,)).astype(config.floatX)
-
-        f1 = theano.function([x], bincount(x))
-        f2 = theano.function([x, w], bincount(x, weights=w))
-        f3 = theano.function([x], bincount(x, minlength=23))
-        f4 = theano.function([x], bincount(x, minlength=5))
-
-        assert (np.bincount(a) == f1(a)).all()
-        assert np.allclose(np.bincount(a, weights=weights), f2(a, weights))
-        assert (np.bincount(a, minlength=23) == f3(a)).all()
-        assert (np.bincount(a, minlength=5) == f3(a)).all()
+        for dtype in ('int8', 'int16', 'int32', 'int64',
+                      'uint8', 'uint16', 'uint32', 'uint64'):
+            # uint64 always fails
+            # int64 and uint32 also fail if python int are 32-bit
+            int_bitwidth = theano.gof.cmodule.python_int_bitwidth()
+            if int_bitwidth == 64:
+                numpy_unsupported_dtypes = ('uint64',)
+            if int_bitwidth == 32:
+                numpy_unsupported_dtypes = ('uint32', 'int64', 'uint64')
+
+            x = T.vector('x', dtype=dtype)
+
+            if dtype in numpy_unsupported_dtypes:
+                self.assertRaises(TypeError, bincount, x)
+
+            else:
+                a = np.random.random_integers(50, size=(25)).astype(dtype)
+                weights = np.random.random((25,)).astype(config.floatX)
+
+                f1 = theano.function([x], bincount(x))
+                f2 = theano.function([x, w], bincount(x, weights=w))
+                f3 = theano.function([x], bincount(x, minlength=23))
+                f4 = theano.function([x], bincount(x, minlength=5))
+
+                assert (np.bincount(a) == f1(a)).all()
+                assert np.allclose(np.bincount(a, weights=weights),
+                                   f2(a, weights))
+                assert (np.bincount(a, minlength=23) == f3(a)).all()
+                assert (np.bincount(a, minlength=5) == f4(a)).all()
 
     def test_infer_shape(self):
-        x = T.lvector('x')
-
-        self._compile_and_check([x],
-                                [bincount(x)],
-                                [np.random.random_integers(50, size=(25,))],
-                                self.op_class)
-
-        weights = np.random.random((25,)).astype(config.floatX)
-        self._compile_and_check([x],
-                                [bincount(x, weights=weights)],
-                                [np.random.random_integers(50, size=(25,))],
-                                self.op_class)
-
-        self._compile_and_check([x],
-                                [bincount(x, minlength=60)],
-                                [np.random.random_integers(50, size=(25,))],
-                                self.op_class)
-
-        self._compile_and_check([x],
-                                [bincount(x, minlength=5)],
-                                [np.random.random_integers(50, size=(25,))],
-                                self.op_class)
+        for dtype in ('int8', 'int16', 'int32', 'int64',
+                      'uint8', 'uint16', 'uint32', 'uint64'):
+            # uint64 always fails
+            # int64 and uint32 also fail if python int are 32-bit
+            int_bitwidth = theano.gof.cmodule.python_int_bitwidth()
+            if int_bitwidth == 64:
+                numpy_unsupported_dtypes = ('uint64',)
+            if int_bitwidth == 32:
+                numpy_unsupported_dtypes = ('uint32', 'int64', 'uint64')
+
+            x = T.vector('x', dtype=dtype)
+
+            if dtype in numpy_unsupported_dtypes:
+                self.assertRaises(TypeError, bincount, x)
+
+            else:
+                self._compile_and_check(
+                        [x],
+                        [bincount(x)],
+                        [np.random.random_integers(
+                            50, size=(25,)).astype(dtype)],
+                        self.op_class)
+
+                weights = np.random.random((25,)).astype(config.floatX)
+                self._compile_and_check(
+                        [x],
+                        [bincount(x, weights=weights)],
+                        [np.random.random_integers(
+                            50, size=(25,)).astype(dtype)],
+                        self.op_class)
+
+                self._compile_and_check(
+                        [x],
+                        [bincount(x, minlength=60)],
+                        [np.random.random_integers(
+                            50, size=(25,)).astype(dtype)],
+                        self.op_class)
+
+                self._compile_and_check(
+                        [x],
+                        [bincount(x, minlength=5)],
+                        [np.random.random_integers(
+                            50, size=(25,)).astype(dtype)],
+                        self.op_class)
 
 
 class TestDiffOp(utt.InferShapeTester):